Quality RTOS & Embedded Software

 Real time embedded FreeRTOS RSS feed 
Real time embedded FreeRTOS mailing list 
Quick Start Supported MCUs PDF Books Trace Tools Ecosystem TCP & FAT Training




Loading

Problems while enabling nested interrupts on Zynq-7000

Posted by devil1989 on July 21, 2017

Hello, 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 (https://www.xilinx.com/support/answers/54128.html) says, I call XScuGicCPUWriteReg(IntcInstancePtr, XSCGICBINPTOFFSET,0x03) during the interrupt controller initialization, before the XilExceptionInit(). Then, my ISR routine is something like this: ~~~ void Handler() { BaseTypet xTaskWokenByReceive = pdFALSE; BaseTypet xHigherPriorityTaskWoken = pdFALSE;

Xil_EnableNestedInterrupts();

if(xQueueReceiveFromISR(<argA>, <argB>, &xTaskWokenByReceive) == pdTRUE)
{
	vTaskNotifyGiveFromISR(<argC>, &xHigherPriorityTaskWoken);
}
else if(xQueueReceiveFromISR(<argD>, <argE>, &xTaskWokenByReceive) == pdTRUE)
{
	vTaskNotifyGiveFromISR(<argF>, &xHigherPriorityTaskWoken);
}
else
{
	// 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 portENDSWITCHINGISR(). */ XilDisableNestedInterrupts(); portYIELDFROMISR(xHigherPriorityTaskWoken); } ~~~ The priority of the related interrupt is equal to configMAXAPICALLINTERRUPT_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 configMAXSYSCALLINTERRUPTPRIORITY calls an ISR safe FreeRTOS API function. ISR safe FreeRTOS API functions must only be called from interrupts that have been assigned a priority at or below configMAXSYSCALLINTERRUPTPRIORITY.

	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
	configMAX_SYSCALL_INTERRUPT_PRIORITY.

	FreeRTOS maintains separate thread and ISR API functions to ensure
	interrupt entry is as fast and simple as possible. */
	configASSERT( portICCRPR_RUNNING_PRIORITY_REGISTER >= ( uint32_t ) ( configMAX_API_CALL_INTERRUPT_PRIORITY << portPRIORITY_SHIFT ) );

	/* 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). */
	configASSERT( ( portICCBPR_BINARY_POINT_REGISTER & portBINARY_POINT_BITS ) <= portMAX_BINARY_POINT_VALUE );
}

~~~

The second one from the last configASSERT of the function vPortEnterCritical(): ~~~ void vPortEnterCritical( void ) { /* Mask interrupts up to the max syscall interrupt priority. */ ulPortSetInterruptMask();

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

/* 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!

Enrico


Problems while enabling nested interrupts on Zynq-7000

Posted by rtel on July 21, 2017

I don't know what the XilEnableNestedInterrupts() and XilDisableNestedInterrupts() 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: http://www.freertos.org/Using-FreeRTOS-on-Cortex-A-Embedded-Processors.html - in particular make sure the vApplicationIRQHandler() function is enabling interrupts again before calling the handler installed for the interrupt.


Problems while enabling nested interrupts on Zynq-7000

Posted by devil1989 on July 24, 2017

Hi! 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 FreeRTOSApplicationIRQHandler( uint32t ulICCIAR ) { extern const XScuGicConfig XScuGicConfigTable[]; static const XScuGicVectorTableEntry *pxVectorTable = XScuGicConfigTable[ XPARSCUGICSINGLEDEVICEID ].HandlerTable; uint32t ulInterruptID; const XScuGicVectorTableEntry *pxVectorEntry;

/* The ID of the interrupt is obtained by bitwise anding the ICCIAR value
with 0x3FF. */
ulInterruptID = ulICCIAR & 0x3FFUL;
if( ulInterruptID < XSCUGIC_MAX_NUM_INTR_INPUTS )
{
	/* 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. Enrico


Problems while enabling nested interrupts on Zynq-7000

Posted by rtel on 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.


[ Back to the top ]    [ About FreeRTOS ]    [ Sitemap ]    [ ]




Copyright (C) 2004-2010 Richard Barry. Copyright (C) 2010-2016 Real Time Engineers Ltd.
Any and all data, files, source code, html content and documentation included in the FreeRTOSTM distribution or available on this site are the exclusive property of Real Time Engineers Ltd.. See the files license.txt (included in the distribution) and this copyright notice for more information. FreeRTOSTM and FreeRTOS.orgTM are trade marks of Real Time Engineers Ltd.

Latest News:

FreeRTOS V9.0.0 is now available for download.


Free TCP/IP and file system demos for the RTOS


Sponsored Links

⇓ Now With No Code Size Limit! ⇓
⇑ Free Download Without Registering ⇑


FreeRTOS Partners

ARM Connected RTOS partner for all ARM microcontroller cores

Renesas Electronics Gold Alliance RTOS Partner.jpg

Microchip Premier RTOS Partner

RTOS partner of NXP for all NXP ARM microcontrollers

Atmel RTOS partner supporting ARM Cortex-M3 and AVR32 microcontrollers

STMicro RTOS partner supporting ARM7, ARM Cortex-M3, ARM Cortex-M4 and ARM Cortex-M0

Xilinx Microblaze and Zynq partner

Silicon Labs low power RTOS partner

Altera RTOS partner for Nios II and Cortex-A9 SoC

Freescale Alliance RTOS Member supporting ARM and ColdFire microcontrollers

Infineon ARM Cortex-M microcontrollers

Texas Instruments MCU Developer Network RTOS partner for ARM and MSP430 microcontrollers

Cypress RTOS partner supporting ARM Cortex-M3

Fujitsu RTOS partner supporting ARM Cortex-M3 and FM3

Microsemi (previously Actel) RTOS partner supporting ARM Cortex-M3

Atollic Partner

IAR Partner

Keil ARM Partner

Embedded Artists