How to Get Back to Main after Calling Interrupt

[SteveZ-Cal]

Is there a way for interrupt to get back to main after it execute its my_isr function?

It seems that it keep executing

printf("INSIDE my_isr\n");

whenever an interrupt occurs.

/*******Define how ISR handle Interrupt ********/
void my_isr(void *arg){
	printf("INSIDE my_isr\n");
	return 1;
}

void my_isr_installer(void){
	printf("Inside my_isr_installer\n");
	IRQ_CONNECT(MY_DEV_IRQ, MY_DEV_PRIO, my_isr, MY_ISR_ARG, MY_IRQ_FLAGS);
	printf("ISR-Enabled\n");
   	irq_enable(MY_DEV_IRQ);
	printf("IRQ-Enabled\n");
}

void main(void){

	printf("START IN MAIN\n");
	my_isr_installer();

       (other tasks) .... 
}

[arbrauns]

You will need to describe your problem more precisely, because your title is exactly how interrupts normally work. They interrupt the normal program flow, do their thing, and when they're done, the program continues where it was interrupted.

[SteveZ-Cal]

main.c

//task0, task1, task2 come from separate .h file

#include "task0.h"
#include "task1.h"
#include "task2.h"

/* size of stack area used by each thread */
#define STACKSIZE 1024

/* scheduling priority used by each thread */
#define PRIORITY 7

K_THREAD_STACK_DEFINE(task1_stack_area, STACKSIZE);
static struct k_thread task1_data;

K_THREAD_STACK_DEFINE(task2_stack_area, STACKSIZE);
static struct k_thread task2_data;

K_THREAD_STACK_DEFINE(task0_stack_area, STACKSIZE);
static struct k_thread task0_data;


/*******Define how ISR handle Interrupt ********/
void my_isr(void *arg){
	printf("INSIDE my_isr\n");
	return 1;
}

void my_isr_installer(void){
	printf("Inside my_isr_installer\n");
	IRQ_CONNECT(MY_DEV_IRQ, MY_DEV_PRIO, my_isr, MY_ISR_ARG, MY_IRQ_FLAGS);
	printf("ISR-Enabled\n");
   	irq_enable(MY_DEV_IRQ);
	printf("IRQ-Enabled\n");
}


void main(void) {

        my_isr_installer();

        /****************Initilizing Threads**************************/
       
       	k_tid_t task1_id = k_thread_create(&task1_data, task1_stack_area, K_THREAD_STACK_SIZEOF(task1_stack_area), 
					task1, NULL, NULL, NULL, PRIORITY, 0, K_FOREVER);

       	k_tid_t task2_id = k_thread_create(&task2_data, task2_stack_area, K_THREAD_STACK_SIZEOF(task2_stack_area), 
					task2, NULL, NULL, NULL, PRIORITY, 0, K_FOREVER);

	k_tid_t task0_id = k_thread_create(&task0_data, task0_stack_area, K_THREAD_STACK_SIZEOF(task0_stack_area), 
					task0, NULL, NULL, NULL, PRIORITY, 0, K_FOREVER);
	k_thread_name_set(task0_id, "task0");
         
        /****************End of Initilizing Threads**************************/

        k_thread_start(task0_id);
	k_thread_start(task1_id);
	k_thread_start(task2_id);

}

apply for n = 0, 1, 2

taskn.h

void taskn(void){

while(1){

printf("Inside Taskn \n);

k_yield(); // for context switching

}

}

Below is the Behavior when I interrupt:

Inside my_isr_installer
ISR-Enabled
IRQ-Enabled
Inside Task0
Inside Task1
Inside Task2
Inside Task0
Inside Task1
(I interrupt just once)
INSIDE my_isr
INSIDE my_isr
INSIDE my_isr
INSIDE my_isr
INSIDE my_isr
INSIDE my_isr
..... (keep printing INSIDE my_isr)

After calling interrupt, it never returns back to the Task2 to execute
Could this be a problem related to using k_yield() as context switching? Or should I use other API (other than k_sleep()) for context switching?

[arbrauns]

Sounds more like you're not acknowledging the interrupt, so it keeps firing. Impossible to say without knowing what interrupt and for what device it is.

[SteveZ-Cal]

FPGA Setup

NEORV32 RISC-V Processor on Cyclone V De0-CV
IMEM: 128KB
DMEM: 64KB

NEORV32 Version: V1.8.6 (Purpose: compatible to Zephyr latest version)

CFS_INTERRUPT

Based on the Official Documentation on CFS Interrupt (https://stnolting.github.io/neorv32/#_neorv32_specific_fast_interrupt_requests);

I'm trying to only access Channel 1, CFS is not a device it's a module for (adding additional functionality to the NEORV32 RISC-V Processor)

Below is its corresponding FIRQ Table for neorv32

intc: interrupt-controller {
			compatible = "riscv,cpu-intc";
			interrupt-controller;
			#address-cells = <1>;
			#interrupt-cells = <1>;

			firq: firq {
				#address-cells = <1>;
				interrupt-map-mask = <0x0 0xffffffff>;
				interrupt-map = <
					0  0 &intc 0 16
					0  1 &intc 0 17
					0  2 &intc 0 18
					0  3 &intc 0 19
					0  4 &intc 0 20
					0  5 &intc 0 21
					0  6 &intc 0 22
					0  7 &intc 0 23
					0  8 &intc 0 24
					0  9 &intc 0 25
					0 10 &intc 0 26
					0 11 &intc 0 27
					0 12 &intc 0 28
					0 13 &intc 0 29
					0 14 &intc 0 30
					0 15 &intc 0 31
				>;
				#interrupt-cells = <1>;
			};
		};

Below is how I Define IRQ

Below is how I Define IRQ
#define MY_DEV_IRQ 17
#define MY_DEV_IRQ_PRIO 1
#define MY_ISR_ARG 0
#define MY_IRQ_FLAGS 0

It seems that on Zephyr side, I haven't see any API that could be used to acknowledging the Interrupt, what would be a corresponding API for that? Btw, do I need to clear the bit of the irq after calling interrupt?

[arbrauns]

I haven't dug in very far, but it seems like the documentation you linked already provides some information on this:

The CFS provides a single high-level-triggered interrupt request signal mapped to the CPU’s fast interrupt channel 1. Once triggered, the interrupt becomes pending (if enabled in the mis CSR) and has to be explicitly cleared again by writing zero to the according mip CSR bit. See section Processor Interrupts for more information.

The RISC-V standard interrupts are level-triggered and high-active. Once set, the signal has to remain high until the interrupt request is explicitly acknowledged (e.g. writing to a memory-mapped register). The RISC-V standard interrupts CANNOT be acknowledged/cleared by writing zero to the according mip CSR bit.

https://stnolting.github.io/neorv32/#_custom_functions_subsystem_cfs

You need find out how to make the CFS stop raising an interrupt, which is obviously highly hardware-specific.