uint32_t _Thread_Dispatch_set_disable_level(uint32_t value) { ISR_Level isr_level; uint32_t disable_level; _ISR_Disable( isr_level ); disable_level = _Thread_Dispatch_disable_level; _ISR_Enable( isr_level ); /* * If we need the dispatch level to go higher * call increment method the desired number of times. */ while ( value > disable_level ) { disable_level = _Thread_Dispatch_increment_disable_level(); } /* * If we need the dispatch level to go lower * call increment method the desired number of times. */ while ( value < disable_level ) { disable_level = _Thread_Dispatch_decrement_disable_level(); } return value; }
void __ISR_Handler( uint32_t vector) { ISR_Level level; _ISR_Disable( level ); _Thread_Dispatch_increment_disable_level(); #if (CPU_HAS_SOFTWARE_INTERRUPT_STACK == TRUE) if ( _ISR_Nest_level == 0 ) { /* Install irq stack */ _old_stack_ptr = stack_ptr; stack_ptr = _CPU_Interrupt_stack_high; } #endif _ISR_Nest_level++; _ISR_Enable( level ); /* call isp */ if ( _ISR_Vector_table[ vector]) (*_ISR_Vector_table[ vector ])( vector ); _ISR_Disable( level ); _Thread_Dispatch_decrement_disable_level(); _ISR_Nest_level--; #if (CPU_HAS_SOFTWARE_INTERRUPT_STACK == TRUE) if ( _ISR_Nest_level == 0 ) /* restore old stack pointer */ stack_ptr = _old_stack_ptr; #endif _ISR_Enable( level ); if ( _ISR_Nest_level ) return; if ( _Thread_Dispatch_in_critical_section() ) { return; } if ( _Thread_Dispatch_necessary ) { _Thread_Dispatch(); } }
void __ISR_Handler(uint32_t vector, CPU_Interrupt_frame *ifr) { register uint32_t level; _exception_stack_frame = NULL; /* Interrupts are disabled upon entry to this Handler */ _Thread_Dispatch_increment_disable_level(); #if( CPU_HAS_SOFTWARE_INTERRUPT_STACK == TRUE) if ( _ISR_Nest_level == 0 ) { /* Install irq stack */ _old_stack_ptr = stack_ptr; stack_ptr = _CPU_Interrupt_stack_high - 4; } #endif _ISR_Nest_level++; if ( _ISR_Vector_table[ vector] ) { (*_ISR_Vector_table[ vector ])(vector, ifr); }; /* Make sure that interrupts are disabled again */ _CPU_ISR_Disable( level ); _ISR_Nest_level--; #if( CPU_HAS_SOFTWARE_INTERRUPT_STACK == TRUE) if( _ISR_Nest_level == 0) stack_ptr = _old_stack_ptr; #endif _Thread_Dispatch_decrement_disable_level(); _CPU_ISR_Enable( level ); if ( _ISR_Nest_level ) return; if ( _Thread_Dispatch_necessary && !_Thread_Dispatch_in_critical_section() ) { /* save off our stack frame so the context switcher can get to it */ _exception_stack_frame = ifr; _Thread_Dispatch(); /* and make sure its clear in case we didn't dispatch. if we did, its * already cleared */ _exception_stack_frame = NULL; } }
void __ISR_Handler(void) { register uint32_t level; /* Interrupts are disabled upon entry to this Handler */ #if( CPU_HAS_SOFTWARE_INTERRUPT_STACK == TRUE) if ( _ISR_Nest_level == 0 ) { /* Install irq stack */ _old_stack_ptr = stack_ptr; stack_ptr = _CPU_Interrupt_stack_high - 4; } #endif _ISR_Nest_level++; _Thread_Dispatch_increment_disable_level(); __IIC_Handler(); /* Make sure that interrupts are disabled again */ _CPU_ISR_Disable( level ); _Thread_Dispatch_decrement_disable_level(); _ISR_Nest_level--; if( _ISR_Nest_level == 0) { #if( CPU_HAS_SOFTWARE_INTERRUPT_STACK == TRUE) stack_ptr = _old_stack_ptr; #endif if( !_Thread_Dispatch_in_critical_section() ) { if ( _Thread_Dispatch_necessary ) { _CPU_ISR_Enable( level ); _Thread_Dispatch(); /* may have switched to another task and not return here immed. */ _CPU_ISR_Disable( level ); /* Keep _pairs_ of Enable/Disable */ } } } _CPU_ISR_Enable( level ); }
uint32_t _Thread_Dispatch_set_disable_level(uint32_t value) { /* * If we need the dispatch level to go higher * call increment method the desired number of times. */ while ( value > _Thread_Dispatch_disable_level ) { _Thread_Dispatch_increment_disable_level(); } /* * If we need the dispatch level to go lower * call increment method the desired number of times. */ while ( value < _Thread_Dispatch_disable_level ) { _Thread_Dispatch_decrement_disable_level(); } return value; }
int _ISR_SMP_Exit(void) { ISR_Level level; int retval; retval = 0; _ISR_Disable_on_this_core( level ); _ISR_Nest_level--; if ( _ISR_Nest_level == 0 ) { if ( _Thread_Dispatch_necessary ) { if ( _Thread_Dispatch_get_disable_level() == 1 ) { retval = 1; } } } /* * SPARC has special support to avoid some nasty recursive type behaviour. * When dispatching in a thread and we want to return to it then it needs * to finish. */ #if defined(__sparc__) if ( _CPU_ISR_Dispatch_disable ) retval = 0; #endif _ISR_Enable_on_this_core( level ); _Thread_Dispatch_decrement_disable_level(); if ( retval == 0 ) _SMP_Request_other_cores_to_dispatch(); return retval; }
void _Thread_Enable_dispatch( void ) { if ( _Thread_Dispatch_decrement_disable_level() ) return; _Thread_Dispatch(); }