void interrupt Interrupt10( union REGS r ) { if( r.w.ax == 0x1103 ) { ActFontTbls = r.h.bl; } _chain_intr( _old10 ); }
/* * XMemIntHandler - extended memory interrupt handler */ void __interrupt XMemIntHandler( volatile union INTPACK r ) { if( r.h.ah != XMEM_MEMORY_SIZE ) { _chain_intr( XMemCtrl.xtd_vector ); } r.w.ax = 0; /* no free extended memory left */ r.w.flags &= ~INTR_CF; /* turn off carry flag */ } /* XMemIntHandler */
void interrupt far handler(void) { char i; asm { mov i, ah } function[i]++; _chain_intr(original_handler); }
void interrupt far PAS_ServiceInterrupt ( void ) { #ifdef USESTACK // save stack GetStack( &oldStackSelector, &oldStackPointer ); // set our stack SetStack( StackSelector, StackPointer ); #endif irqstatus = PAS_Read( InterruptStatus ); if ( ( irqstatus & SampleBufferInterruptFlag ) == 0 ) { #ifdef USESTACK // restore stack SetStack( oldStackSelector, oldStackPointer ); #endif _chain_intr( PAS_OldInt ); } // Clear the interrupt irqstatus &= ~SampleBufferInterruptFlag; PAS_Write( InterruptStatus, irqstatus ); // send EOI to Interrupt Controller if ( PAS_Irq > 7 ) { outp( 0xA0, 0x20 ); } outp( 0x20, 0x20 ); // Keep track of current buffer PAS_CurrentDMABuffer += PAS_TransferLength; if ( PAS_CurrentDMABuffer >= PAS_DMABufferEnd ) { PAS_CurrentDMABuffer = PAS_DMABuffer; } // Call the caller's callback function if ( PAS_CallBack != NULL ) { PAS_CallBack(); } #ifdef USESTACK // restore stack SetStack( oldStackSelector, oldStackPointer ); #endif }
static void __interrupt __far TS_ServiceSchedule ( void ) { task *ptr; task *next; TS_InInterrupt = TRUE; #ifdef USESTACK // save stack GetStack( &oldStackSelector, &oldStackPointer ); // set our stack SetStack( StackSelector, StackPointer ); #endif ptr = TaskList->next; while( ptr != TaskList ) { next = ptr->next; if ( ptr->active ) { ptr->count += TaskServiceRate; //JIM // if ( ptr->count >= ptr->rate ) while( ptr->count >= ptr->rate ) { ptr->count -= ptr->rate; ptr->TaskService( ptr ); } } ptr = next; } #ifdef USESTACK // restore stack SetStack( oldStackSelector, oldStackPointer ); #endif TaskServiceCount += TaskServiceRate; if ( TaskServiceCount > 0xffffL ) { TaskServiceCount &= 0xffff; _chain_intr( OldInt8 ); } outp( 0x20,0x20 ); TS_InInterrupt = FALSE; }
static void __interrupt timer_handler(union INTPACK regs) { static int bios_counter = 0; timer.ticks++; bios_counter += timer.counter_init; if (bios_counter >= PIT_COUNTER_MAX) { bios_counter -= PIT_COUNTER_MAX; _chain_intr(timer.default_handler); } else { outp(PIC_MASTER_COMMAND, PIC_EOI); } }
/* * handleInt1c - int 0x1c handler (clock timer) */ static void interrupt handleInt1c( void ) { ClockTicks++; cTick1--; if( cTick1 == 0 ) { cTick2--; if( cTick2 == 0 ) { cTick2 = 5; cTick1 = 19; } else { cTick1 = 18; } tSec2++; if( tSec2 > '9' ) { tSec2 = '0'; tSec1++; if( tSec1 > '5' ) { tSec1 = '0'; tMin2++; if( tMin2 > '9' ) { tMin2 = '0'; tMin1++; if( tMin1 > '5' ) { tMin1 = '0'; tHour2++; if( tHour2 > '9' ) { tHour2 = '0'; tHour1++; } else if( tHour2 == '4' && tHour1 == '2' ) { tHour2 = tHour1 = '0'; } } } } } drawClock(); } if( EditFlags.ClockActive && EditFlags.SpinningOurWheels && EditFlags.Spinning ) { *SpinLoc = SpinData[SpinCount]; SpinCount++; if( SpinCount >= 4 ) { SpinCount = 0; } } #if defined( _M_I86 ) || defined( __4G__ ) _chain_intr( oldInt1c ); #endif } /* handleInt1c */
static void __interrupt __far SOUNDSCAPE_ServiceInterrupt ( void ) { // save stack GetStack( &oldStackSelector, &oldStackPointer ); // set our stack SetStack( StackSelector, StackPointer ); if ( !( inp( SOUNDSCAPE_Config.WavePort + AD_STATUS ) & 0x01 ) ) { // restore stack SetStack( oldStackSelector, oldStackPointer ); // Wasn't our interrupt. Call the old one. _chain_intr( SOUNDSCAPE_OldInt ); } // clear the AD-1848 interrupt outp( SOUNDSCAPE_Config.WavePort + AD_STATUS, 0x00 ); // Keep track of current buffer SOUNDSCAPE_CurrentDMABuffer += SOUNDSCAPE_TransferLength; if ( SOUNDSCAPE_CurrentDMABuffer >= SOUNDSCAPE_DMABufferEnd ) { SOUNDSCAPE_CurrentDMABuffer = SOUNDSCAPE_DMABuffer; } // Call the caller's callback function if ( SOUNDSCAPE_CallBack != NULL ) { SOUNDSCAPE_CallBack(); } // restore stack SetStack( oldStackSelector, oldStackPointer ); // send EOI to Interrupt Controller if ( SOUNDSCAPE_Config.WaveIRQ > 7 ) { outp( 0xA0, 0x20 ); } outp( 0x20, 0x20 ); }
static void __interrupt __far timer_irq() { static unsigned long dos_ticks; ticks++; if(++dos_ticks >= ticks_per_dos_intr) { /* I suppose the dos irq handler does the EOI so I shouldn't * do it if I am to call the previous function */ dos_ticks = 0; _chain_intr(prev_timer_intr); /* XXX DOES NOT RETURN */ return; /* just for clarity */ } /* send EOI to the PIC */ outp(PIC1_CMD, OCW2_EOI); }
void __interrupt __far Int21Handler(union INTPACK r) { teefunc = NULL; tee_check_handle = 1; if (tee_handle != -1 && !err_on_write) switch(r.h.ah) { case 0x06: if (r.h.dl == 0xff) break; /* fallthrough (to case 0x02) */ case 0x02: tee_pchar = r.h.dl; tee_func_length = 1; tee_func_buffer = &tee_pchar; teefunc = tee_func_write; break; case 0x09: tee_func_length = 0; tee_func_buffer = MK_FP(r.w.ds, r.x.dx); while(tee_func_buffer[tee_func_length] != '$') { if (tee_func_length >= 0x7fffU) break; /* avoid overrun */ ++tee_func_length; } teefunc = tee_func_write; break; case 0x40: if (r.x.bx != 1 && r.x.bx != 2) break; tee_func_length = r.x.cx; tee_func_buffer = MK_FP(r.w.ds, r.x.dx); tee_check_handle = r.x.bx; teefunc = tee_func_write; break; default: break; } if (teefunc && my_dosisatty(tee_check_handle)) { tee_func_write(tee_func_buffer, tee_func_length); } _chain_intr(org_int21); }
static void _WCINTERRUPT _WCFAR __int_ctrl_break_handler( void ) { #if defined( __386__ ) unsigned save_stacklow; void _WCFAR *save_stack; save_stack = set_stack( &(my_stack[(sizeof(my_stack)-sizeof(my_stack[0]))]) ); save_stacklow = _STACKLOW; _STACKLOW = (unsigned)&my_stack; #endif if(( _RWD_child == 0 ) && ( __int23_exit != __null_int23_exit ) && ( __int23_exit != __restore_int23 )) { _enable(); raise( SIGBREAK ); } else { _chain_intr( __old_int_ctrl_break ); } #if defined( __386__ ) set_stack( save_stack ); _STACKLOW = save_stacklow; #endif }
static void __interrupt __far dos_timer_intr() { ticks++; _chain_intr(prev_timer_intr); /* DOES NOT RETURN */ }
void __interrupt __far key_handler() { unsigned char scancode, breakbit, temp; unsigned short keycode; #ifndef WATCOM_10 #ifndef NDEBUG ubyte * MONO = (ubyte *)(0x0b0000+24*80*2); if ( ((MONO[0]=='D') && (MONO[2]=='B') && (MONO[4]=='G') && (MONO[6]=='>')) || ((MONO[14]=='<') && (MONO[16]=='i') && (MONO[18]=='>') && (MONO[20]==' ') && (MONO[22]=='-')) || ((MONO[0]==200 ) && (MONO[2]==27) && (MONO[4]==17) ) ) _chain_intr( key_data.prev_int_9 ); #endif #endif // Read in scancode scancode = inp( 0x60 ); switch( scancode ) { case 0xE0: key_data.E0Flag = 0x80; break; default: // Parse scancode and break bit if (key_data.E1Flag > 0 ) { // Special code for Pause, which is E1 1D 45 E1 9D C5 key_data.E1Flag--; if ( scancode == 0x1D ) { scancode = KEY_PAUSE; breakbit = 0; } else if ( scancode == 0x9d ) { scancode = KEY_PAUSE; breakbit = 1; } else { break; // skip this keycode } } else if ( scancode==0xE1 ) { key_data.E1Flag = 2; break; } else { breakbit = scancode & 0x80; // Get make/break bit scancode &= 0x7f; // Strip make/break bit off of scancode scancode |= key_data.E0Flag; // Add in extended key code } key_data.E0Flag = 0; // Clear extended key code if (breakbit) { // Key going up keyd_last_released = scancode; keyd_pressed[scancode] = 0; key_data.NumUps[scancode]++; temp = 0; temp |= keyd_pressed[KEY_LSHIFT] || keyd_pressed[KEY_RSHIFT]; temp |= keyd_pressed[KEY_LALT] || keyd_pressed[KEY_RALT]; temp |= keyd_pressed[KEY_LCTRL] || keyd_pressed[KEY_RCTRL]; #ifndef NDEBUG temp |= keyd_pressed[KEY_DELETE]; if ( !(keyd_editor_mode && temp) ) #endif // NOTICE LINK TO ABOVE IF!!!! key_data.TimeKeyHeldDown[scancode] += timer_get_fixed_secondsX() - key_data.TimeKeyWentDown[scancode]; } else { // Key going down keyd_last_pressed = scancode; keyd_time_when_last_pressed = timer_get_fixed_secondsX(); if (!keyd_pressed[scancode]) { // First time down key_data.TimeKeyWentDown[scancode] = timer_get_fixed_secondsX(); keyd_pressed[scancode] = 1; key_data.NumDowns[scancode]++; #ifndef NDEBUG if ( (keyd_pressed[KEY_LSHIFT]) && (scancode == KEY_BACKSP) ) { keyd_pressed[KEY_LSHIFT] = 0; Int5(); } #endif } else if (!keyd_repeat) { // Don't buffer repeating key if repeat mode is off scancode = 0xAA; } if ( scancode!=0xAA ) { keycode = scancode; if ( keyd_pressed[KEY_LSHIFT] || keyd_pressed[KEY_RSHIFT] ) keycode |= KEY_SHIFTED; if ( keyd_pressed[KEY_LALT] || keyd_pressed[KEY_RALT] ) keycode |= KEY_ALTED; if ( keyd_pressed[KEY_LCTRL] || keyd_pressed[KEY_RCTRL] ) keycode |= KEY_CTRLED; #ifndef NDEBUG if ( keyd_pressed[KEY_DELETE] ) keycode |= KEY_DEBUGGED; #endif temp = key_data.keytail+1; if ( temp >= KEY_BUFFER_SIZE ) temp=0; if (temp!=key_data.keyhead) { key_data.keybuffer[key_data.keytail] = keycode; key_data.time_pressed[key_data.keytail] = keyd_time_when_last_pressed; key_data.keytail = temp; } } } } #ifndef NDEBUG #ifdef PASS_KEYS_TO_BIOS _chain_intr( key_data.prev_int_9 ); #endif #endif temp = inp(0x61); // Get current port 61h state temp |= 0x80; // Turn on bit 7 to signal clear keybrd outp( 0x61, temp ); // Send to port temp &= 0x7f; // Turn off bit 7 to signal break outp( 0x61, temp ); // Send to port outp( 0x20, 0x20 ); // Reset interrupt controller }
void __interrupt __far timer_rtn() { ++clock_ticks; _chain_intr( prev_int_1c ); }
void __interrupt __far tick_increment (void) { clock_ticks++; _chain_intr(prev_08); }