int main (void) { // TODO: implement all destructors used in CKernel, otherwise cannot return from main() CKernel Kernel; if (!Kernel.Initialize ()) { DisableInterrupts (); for (;;); return EXIT_HALT; } TShutdownMode ShutdownMode = Kernel.Run (); switch (ShutdownMode) { case ShutdownReboot: reboot (); return EXIT_REBOOT; case ShutdownHalt: default: DisableInterrupts (); for (;;); return EXIT_HALT; } }
// ******** OS_Wait ************ // decrement semaphore and spin/block if less than zero // input: pointer to a counting semaphore // output: none void OS_Wait(Sema4Type *s){ DisableInterrupts(); while( s->Value <= 0){ //TODO: implement Blocking EnableInterrupts(); DisableInterrupts(); } s->Value--; EnableInterrupts(); }
// ******** OS_bWait ************ // if the semaphore is 0 then spin/block // if the semaphore is 1, then clear semaphore to 0 // input: pointer to a binary semaphore // output: none void OS_bWait(Sema4Type *semaPt){ DisableInterrupts(); while( semaPt->Value != 1){ //TODO: implement Blocking EnableInterrupts(); OS_Suspend(); DisableInterrupts(); } semaPt->Value =0; EnableInterrupts(); return; }
// ------------------------- OS_bWait -------------------------------- void OS_bWait(Sema4Type *semaPt){ DisableInterrupts(); while (semaPt->Value <= 0){ unlinkTCB(&Actives, RunPt); linkTCB(&(semaPt->Blocked), RunPt); RunPt->blockSt = semaPt; OS_Suspend(); EnableInterrupts(); } DisableInterrupts(); (*semaPt).Value = 0; EnableInterrupts(); }
static VoiceNode *GUSWAVE_GetVoice ( int handle ) { VoiceNode *voice; unsigned flags; flags = DisableInterrupts(); voice = VoiceList.start; while( voice != NULL ) { if ( handle == voice->handle ) { break; } voice = voice->next; } RestoreInterrupts( flags ); if ( voice == NULL ) { GUSWAVE_SetErrorCode( GUSWAVE_VoiceNotFound ); } return( voice ); }
// ******** OS_SysTick_Handler ************ // Thread Switcher, uses SysTick as periodic timer, calls PendSV to actually switch threads // Implement Thread Manager implicitly here // input: none, uses globals RUNPT and NEXTRUNPT // output: none, should switch threads when finished void OS_SysTick_Handler(void){ tcbType *i, *j; int pri; int x; DisableInterrupts(); //Thread Scheduler if(RRSCHEDULER){ //ROUND ROBBIN SCHEDULER for(i=RUNPT->next; i->sleep>0 || i->blockedOn!=0; i=i->next){ //OLD SLEEP DECRIMENTER //if(i->sleep>0){//decriment sleep counter // i->sleep=i->sleep-1; //} } NEXTRUNPT=i; }else if(PRIORITYSCHEDULER){ //PRIORITY SCHEDULER pri=7; j=RUNPT->next; x=0; do{ x++; //find thread with highest priority that isnt sleeping or blocked if(j->blockedOn==NULL && j->sleep==0 && j->workingPriority<pri){ pri=j->workingPriority; i=j; } j=j->next; //}while(j!=RUNPT->next); }while(x<NUMTHREADS); /* //Priority Scheduler, failed for case where lowest thread got blocked. for(i=RUNPT->next,pri=RUNPT->workingPriority,x=0; i->sleep>0 || i->blockedOn!=NULL || (i->workingPriority > pri); i=i->next, x++){ //Possible ERROR HERE, needs rethought //search for next thread untill you find one that is not sleeping, not blocked, and has a priority equal or less than the current RUNPT if(x>=NUMTHREADS && pri<7){ x=0; pri++; } } */ //OLD SLEEP DECRIMENTER //if(i->sleep>0){//decriment sleep counter // i->sleep=i->sleep-1; //} NEXTRUNPT=i; RUNPT->lastRun=OS_Time(); RUNPT->workingPriority = RUNPT->realPriority; } EnableInterrupts(); //Switch Threads (trigger PendSV) NVIC_INT_CTRL_R = 0x10000000; //PendSV_Handler(); }
/* * This routine will shutdown a serial port; interrupts are disabled, and * DTR is dropped if the hangup on close termio flag is on. */ static void shutdown(struct xmb_serial * info) { volatile unsigned int *uartp; unsigned long flags; if (!(info->flags & ASYNC_INITIALIZED)) return; #ifdef SERIAL_DEBUG_OPEN printk("Shutting down serial port %d (irq %d)....\n", info->line, info->irq); #endif uartp = (volatile unsigned int *) info->addr; save_flags_cli(flags); /* Disable interrupts */ /* Disable interrupts and clear RX FIFO */ DisableInterrupts(uartp); Reset_RX_FIFO(uartp); if (info->xmit_buf) { free_page((unsigned long) info->xmit_buf); info->xmit_buf = 0; } if (info->tty) set_bit(TTY_IO_ERROR, &info->tty->flags); info->flags &= ~ASYNC_INITIALIZED; restore_flags(flags); }
/* * Based on the line number set up the internal interrupt stuff. */ static void xmbrs_irqinit(struct xmb_serial *info) { volatile unsigned int *uartp; switch (info->line) { case 0: case 1: break; default: printk("SERIAL: don't know how to handle UART %d interrupt?\n", info->line); return; } uartp = (volatile unsigned int *) info->addr; /* Clear mask, so no surprise interrupts. */ DisableInterrupts(uartp); if (request_irq(info->irq, xmbrs_interrupt, SA_INTERRUPT, "Microblaze UARTlite", NULL)) { printk("SERIAL: Unable to attach Xilinx UARTlite %d interrupt " "vector=%d\n", info->line, info->irq); } /* Populate the fast IRQ lookup table */ irq_lookup[info->irq] = info; /* UART still can't generate interrupts - leave it this way until it is actually opened */ return; }
void EXTI0_IRQHandler(void) { DisableInterrupts(); PressButtom = TRUE; EXTI_ClearITPendingBit(EXTI_Line0); EnableInterrupts(); }
int main(void){ DisableInterrupts(); TExaS_Init(SSI0_Real_Nokia5110_Scope); // set system clock to 80 MHz Random_Init(1); Nokia5110_Init(); PF1Init(); //SysTick_Init(2666666); //Initialize SysTick with 30 Hz interrupts SysTick_Init(2666666*4); //Increased period by 4 for actual hardware to make the game run at a playable speed Nokia5110_ClearBuffer(); Nokia5110_DisplayBuffer(); // draw buffer ADC0_Init(); Game_Init(); SwitchLed_Init(); Sound_Init(); Timer2_Init(&Sound_Play,7256); //11.025 kHz. 80,000,000/11,025 cycles, which is about 7256 GameOverFlag = 0; EnableInterrupts(); while(1){ while(Semaphore==0){}; Semaphore = 0; if(GameOverFlag){ State_GameOver(); } else{ Draw_GameFrame(); // update the LCD } if((GameOverFlag == 0) && (Check_GameOver())){ //just detected game over Delay100ms(2);//Delay 200ms GameOverFlag = Check_GameOver(); //SysTick_Init(2666666);//Re-initialize with 30 Hz interrupt SysTick_Init(2666666*4); //Increased period by 4 for actual hardware to make the game run at a playable speed } } }
int GUSWAVE_SetPitch ( int handle, int pitchoffset ) { VoiceNode *voice; unsigned flags; flags = DisableInterrupts(); voice = GUSWAVE_GetVoice( handle ); if ( voice == NULL ) { RestoreInterrupts( flags ); GUSWAVE_SetErrorCode( GUSWAVE_VoiceNotFound ); return( GUSWAVE_Warning ); } if ( voice->Active ) { voice->PitchScale = PITCH_GetScale( pitchoffset ); voice->RateScale = ( voice->SamplingRate * voice->PitchScale ) >> 16; gf1_dig_set_freq( voice->GF1voice, voice->RateScale ); }
/* * Setup the timer 0 to generate the tick interrupts at the required frequency. */ static void prvSetupTimerInterrupt( void ) { uint32_t ulCompareMatch; /* Calculate the match value required for our wanted tick rate. */ ulCompareMatch = 1000000 / configTICK_RATE_HZ; /* Protect against divide by zero. Using an if() statement still results in a warning - hence the #if. */ #if portPRESCALE_VALUE != 0 { ulCompareMatch /= ( portPRESCALE_VALUE + 1 ); } #endif DisableInterrupts(); pRegs->CTL = 0x003E0000; pRegs->LOD = ulCompareMatch; pRegs->RLD = ulCompareMatch; pRegs->DIV = portTIMER_PRESCALE; pRegs->CLI = 0; pRegs->CTL = 0x003E00A2; RegisterInterrupt(64, vTickISR, NULL); EnableInterrupt(64); EnableInterrupts(); }
byte MHD_Bridge_detect(void) { byte temp = 0; byte BridgeOn = 0; DisableInterrupts(); msleep(180); if(!gpio_get_value(GPIO_ACCESSORY_INT)&& MHD_HW_IsOn()) { temp = ReadIndexedRegister(INDEXED_PAGE_0, 0x09); if ((temp & RSEN) == 0x00) { BridgeOn = FALSE; //ReadModifyWriteTPI(0x79, SI_BIT_5 | SI_BIT_4, SI_BIT_4); //force HPD to 0 ReadModifyWriteIndexedRegister(INDEXED_PAGE_0, 0x79, SI_BIT_5 | SI_BIT_4, SI_BIT_4); } else { BridgeOn = TRUE; //ReadModifyWriteTPI(0x79, BIT_5 | BIT_4, 0); //back to current state } printk("[MHD] Bridge detect %x :: HPD %d\n",BridgeOn,gpio_get_value(GPIO_HDMI_HPD)); //ReadModifyWriteTPI(0x79, SI_BIT_5 | SI_BIT_4, 0); //back to current state ReadModifyWriteIndexedRegister(INDEXED_PAGE_0, 0x79, SI_BIT_5 | SI_BIT_4, 0); } MHD_INT_clear(); EnableInterrupts(); printk("[MHD]MHD_Bridge_detect -- \n"); return BridgeOn; }
// gets all events EventMaskType GetAllEvents() { DisableInterrupts(); EventMaskType tmpevents = eventmemory; EnableInterrupts(); return tmpevents; }
// gets all events which are set in "eventmask" and returns them EventMaskType GetEvent(EventMaskType eventmask) { DisableInterrupts(); EventMaskType tmpevents = eventmask & eventmemory; EnableInterrupts(); return tmpevents; }
void Touch_BeginWaitForTouch(void){ // XP = 1 XN = DIG IN, INT ON FALL EDGE YP = Hi-Z YN = 0 DisableInterrupts(); // Set XP high TOUCH_XP = 0xFF; // Set YN low TOUCH_YN = 0x00; // Configure XN (PA3) for digital input GPIO_PORTA_DIR_R &= ~0x08; // Configure YP (PE5) for analog Hi-Z GPIO_PORTE_DIR_R &= ~0x20; GPIO_PORTE_DEN_R &= ~0x20; // Setup falling edge interrupt on XN (PA3) GPIO_PORTA_PUR_R |= 0x08; // enable weak pull up GPIO_PORTA_IS_R &= ~0x08; // (d) PF4 is edge-sensitive GPIO_PORTA_IBE_R &= ~0x08; // PF4 is not both edges GPIO_PORTA_IEV_R &= ~0x08; // PF4 falling edge event GPIO_PORTA_ICR_R = 0x08; // (e) clear flag4 GPIO_PORTA_IM_R |= 0x08; // (f) arm interrupt on PF4 NVIC_PRI0_R = (NVIC_PRI7_R&0xFFFFFF00)|0x000000a0; NVIC_EN0_R = NVIC_EN0_INT0; // (h) enable interrupt 30 in NVIC EnableInterrupts(); }
void PAS_SetSampleBufferCount ( void ) { int LoByte; int HiByte; int count; int data; unsigned flags; flags = DisableInterrupts(); // Disable the Sample Buffer Count data = PAS_State->audiofilt; data &= ~SampleBufferCountGateFlag; PAS_Write( AudioFilterControl, data ); PAS_State->audiofilt = data; // Select the Sample Buffer Count data = SelectSampleBufferCount; PAS_Write( LocalTimerControl, data ); PAS_State->tmrctlr = data; count = PAS_TransferLength; // Check if we're using a 16-bit DMA channel if ( PAS_DMAChannel > 3 ) { count >>= 1; }
void PAS_SetSampleRateTimer ( void ) { int LoByte; int HiByte; int data; unsigned flags; flags = DisableInterrupts(); // Disable the Sample Rate Timer data = PAS_State->audiofilt; data &= ~SampleRateTimerGateFlag; PAS_Write( AudioFilterControl, data ); PAS_State->audiofilt = data; // Select the Sample Rate Timer data = SelectSampleRateTimer; PAS_Write( LocalTimerControl, data ); PAS_State->tmrctlr = data; LoByte = lobyte( PAS_TimeInterval ); HiByte = hibyte( PAS_TimeInterval ); // Program the Sample Rate Timer PAS_Write( SampleRateTimer, LoByte ); PAS_Write( SampleRateTimer, HiByte ); PAS_State->samplerate = PAS_TimeInterval; RestoreInterrupts( flags ); }
void CondBroadcast (struct Cond *cond) { struct Process *proc; if (current_process == NULL) return; do { DisableInterrupts(); proc = LIST_HEAD (&cond->blocked_list); if (proc != NULL) { LIST_REM_HEAD (&cond->blocked_list, blocked_entry); proc->state = PROC_STATE_READY; SchedReady (proc); Reschedule(); } proc = LIST_HEAD (&cond->blocked_list); EnableInterrupts(); } while (proc != NULL); }
int GUSWAVE_VoicesPlaying ( void ) { int index; int NumVoices = 0; unsigned flags; flags = DisableInterrupts(); for( index = 0; index < GUSWAVE_MaxVoices; index++ ) { if ( GUSWAVE_Voices[ index ].Active ) { NumVoices++; } } RestoreInterrupts( flags ); if ( GUS_Debug ) { DB_printf( "Number of voices = %d.\n", NumVoices ); } return( NumVoices ); }