/* * Get memory */ LOCAL void* imalloc( size_t size, IMACB *imacb ) { QUEUE *q; VP mem; UW imask; /* If it is smaller than the minimum fragment size, allocate the minimum size to it. */ if ( size < MIN_FRAGMENT ) { size = MIN_FRAGMENT; } size = ROUND(size); DI(imask); /* Exclusive control by interrupt disable */ SpinLock(&MemLockObj); /* Search FreeQue */ q = searchFreeArea(size, imacb); if ( q != &imacb->freeque ) { /* There is free area: Split from FreeQue once */ removeFreeQue(q); q = q - 1; } else { /* Reserve new pages because there is no free space */ QUEUE *e; size_t n; /* Reserve pages */ SpinUnlock(&MemLockObj); EI(imask); n = PageCount(size + sizeof(QUEUE) * 2); q = GetSysMemBlk(n, imacb->mematr); if ( q == NULL ) { goto err_ret; /* Insufficient memory */ } DI(imask); SpinLock(&MemLockObj); /* Register on AreaQue */ e = (QUEUE*)((VB*)q + n * pagesz) - 1; insertAreaQue(&imacb->areaque, e); insertAreaQue(&imacb->areaque, q); setAreaFlag(q, AREA_TOP); setAreaFlag(e, AREA_END); } /* Allocate memory */ mem = mem_alloc(q, size, imacb); SpinUnlock(&MemLockObj); EI(imask); return mem; err_ret: BMS_DEBUG_PRINT(("imalloc error\n")); return NULL; }
int uart_putchar(unsigned char c) { int buffer_loc; if(c == '\n') { while(uart_putchar('\r')) { ; } } if(trans_buffer_size < BUFFER_SIZE) { DI(); buffer_loc = (trans_buffer_current + trans_buffer_size) % BUFFER_SIZE; trans_buffer[buffer_loc] = c; trans_buffer_size++; //trigger the interrupt if already ready to transmit if((U0STAT0 & UART_TRAN_RDY) && ((IRQ0SET & UART_IRQ_TRAN) == 0)) { IRQ0SET |= UART_IRQ_TRAN; } EI(); } else { return 1; } return 0; }
void led_display_text(const unsigned char *msg) { char *new_msg; msg_size = strlen(msg); new_msg = malloc(sizeof(*new_msg) * (msg_size + 2)); //+2 for space pad and null terminator if(!new_msg) { msg_size = 0; } else { memcpy(new_msg, msg, msg_size); //space pads the wrap-around if(msg_size > 4) { new_msg[msg_size] = ' '; ++msg_size; } new_msg[msg_size] = '\0'; DI(); if(led_msg != NULL) { free(led_msg); } led_msg = new_msg; msg_pos = 0; row_pos = 0; led_set_draw_chars(); EI(); } }
/** * @param timer The timer to stop */ void hal_timer_stop(char timer) { DI(); switch (timer) { case HAL_TIMER_0: T0CTL &= ~0x80; //Disable timer break; case HAL_TIMER_1: T1CTL &= ~0x80; break; case HAL_TIMER_2: T2CTL &= ~0x80; break; case HAL_TIMER_3: T3CTL &= ~0x80; break; default: break; } EI(); }
SifRpcDataQueue_t * SifSetRpcQueue(SifRpcDataQueue_t *qd, int thread_id) { SifRpcDataQueue_t *queue = NULL; DI(); qd->thread_id = thread_id; qd->active = 0; qd->link = NULL; qd->start = NULL; qd->end = NULL; qd->next = NULL; if (!_sif_rpc_data.active_queue) { _sif_rpc_data.active_queue = qd; } else { queue = _sif_rpc_data.active_queue; while ((queue = queue->next)) ; queue->next = qd; } EI(); return queue; }
SifRpcServerData_t * SifRegisterRpc(SifRpcServerData_t *sd, int sid, SifRpcFunc_t func, void *buff, SifRpcFunc_t cfunc, void *cbuff, SifRpcDataQueue_t *qd) { SifRpcServerData_t *server; DI(); sd->link = NULL; sd->next = NULL; sd->sid = sid; sd->func = func; sd->buff = buff; sd->cfunc = cfunc; sd->cbuff = cbuff; sd->base = qd; if (!(server = qd->link)) { qd->link = sd; } else { while ((server = server->next)) ; server->next = sd; } EI(); return server; }
int buscarIzquierdaAVL( AVL *a, int dato, int *band ) { int retAux; retAux = eliminaAVL( &(*a)->izq, dato, band ); if( *band ) { if( (*a) -> fe == 0 ) { (*a) -> fe = 1; *band = 0; }else if( (*a) -> fe == -1 ) (*a) -> fe = 0; else { if( (*a) -> der -> fe >= 0 ) { if( (*a) -> der -> fe == 0 ) *band = 0; DD( a ); }else DI( a ); } } return( retAux ); }
int eliminaAVL( AVL *a, int dato, int *band ) { int ret; AVL aux; if( !*a ) *band = ret = 0; else { if( dato == (*a) -> info ) { ret = *band = 1; aux = *a; if( !(*a) -> izq ) *a = (*a)-> der; else if( !(*a) -> der ) *a = (*a) -> izq; else { recorreIzqDerAVL( &(*a) -> izq, &aux, band ); (*a) -> info = aux -> info; if( *band ) { if( (*a) -> fe == 0 ) { (*a) -> fe = 1; *band = 0; }else if( (*a) -> fe == -1 ) (*a) -> fe = 0; else { if( (*a) -> der -> fe >= 0 ) { if( (*a) -> der -> fe == 0 ) *band = 0; DD( a ); }else DI( a ); } } } free( aux ); }else if( dato < (*a) -> info ) ret = buscarIzquierdaAVL( a, dato, band ); else if( dato > (*a) -> info ) ret= buscarDerechaAVL( a, dato, band ); } return( ret ); }
/*********************************************************************************************************************** * Function Name: R_Systeminit * Description : This function initializes every macro. * Arguments : None * Return Value : None ***********************************************************************************************************************/ void R_Systeminit(void) { DI(); /* Enable writing to registers related to operating modes, LPC, CGC and ATCM */ SYSTEM.PRCR.LONG = 0x0000A50BU; /* Enable writing to MPC pin function control registers */ MPC.PWPR.BIT.B0WI = 0U; MPC.PWPR.BIT.PFSWE = 1U; r_set_exception_handler(); /* Set peripheral settings */ R_CGC_Create(); R_ICU_Create(); R_PORT_Create(); R_TPU_Create(); R_RSPI1_Create(); R_MPC_Create(); R_SCIFA2_Create(); /* Disable writing to MPC pin function control registers */ MPC.PWPR.BIT.PFSWE = 0U; MPC.PWPR.BIT.B0WI = 1U; /* Enable protection */ SYSTEM.PRCR.LONG = 0x0000A500U; EI(); }
int io_init() { int i; int res; it_g = comedi_open("/dev/comedi0"); if (it_g == NULL) return -1; // init 3 inputs and 3 outputs for(i=1; i<4; i++) { res = comedi_dio_config(it_g, IO_DEV, DI(i), COMEDI_INPUT); if (res<0) return res; res = comedi_dio_config(it_g, IO_DEV, DO(i), COMEDI_OUTPUT); if (res<0) return res; res = comedi_dio_write(it_g, IO_DEV, DO(i), 0); if (res<0) return res; } // set outputs to high for(i=1; i<4; i++) { comedi_dio_write(it_g, IO_DEV, DO(i), 1); } return 1; }
int main(){ DI();//disable interrupts or hell breaks loose during hardware config construct_system();//bind device addresses init_system();//init devices //clear all interrupts clearall_interrupts(); EI();//enable interrupts: we have UART_recieve //set the lcd contrast //lcd_contrast(0x42); lcd_contrast(0x32); //clear the lcd clearram(); //show boot up message show_bootup(); //clear boot message clearram(); //screen layout screen_layout(); send(1, 225); send(1, 255); send(1, 2); while(1) { get_temperature1(); get_temperature2(); get_light(); get_pressure(); get_humidity(); get_soilwetness(); display(); delay_ms(800); } return 0; }
int ki_wait (struct k_t *sem, int timeout) { // used by msg system DI (); if (0 < sem->cnt1) { // lucky that we do not need to wait ? sem->cnt1--; // Salute to Dijkstra return (0); } if (timeout == -1) { // no luck, dont want to wait so bye bye return (-2); } // from here we want to wait pRun->cnt2 = timeout; // if 0 then wait forever if (timeout) pRun->cnt3 = (int) sem; // nasty keep ref to semaphor // so we can be removed if timeout occurs sem->cnt1--; // Salute to Dijkstra enQ (sem, deQ (pRun)); ki_task_shift (); // call enables NOT interrupt on return return ((char) (pRun->cnt2)); // 0: ok, -1: timeout }
int PS2CamReadPacket(int handle) { int *ret; int *iop_addr; WaitSema(sem); ret = (int *)&data[0]; ret[0] = handle; SifCallRpc(&cdata, PS2CAM_RPC_READPACKET, 0, (void*)(&data[0]),4,(void*)(&data[0]),4*2,0,0); if(ret[0] < 0) return ret[0]; DI(); ee_kmode_enter(); iop_addr = (int *)(0xbc000000+ret[1]); memcpy(&campacket[0],iop_addr, ret[0]); ee_kmode_exit(); EI(); //if i add a printf here, the ps2 will exit to sony's explorer SignalSema(sem); return ret[0]; }
char ki_receive (struct k_msg_t *pB, void *el, int *lost_msg) { int i; char r, *pSrc, *pDst; // can be called from ISR bq no blocking DI (); // just to be sure if (0 <= (r = ki_wait (pB->sem, -1))) { pDst = (char *) el; pB->r++; pB->cnt--; // got one if (pB->nr_el <= pB->r) { pB->r = 0; } pSrc = pB->pBuf + pB->r * pB->el_size; for (i = 0; i < pB->el_size; i++) { *(pDst++) = *(pSrc++); } if (lost_msg) { *lost_msg = pB->lost_msg; pB->lost_msg = 0; } return (r); // yes } return (-1); // nothing for you my friend }
int k_mut_ceil_enter (struct k_t *sem, int timeout) { int retval; DI (); // if ceiling_prio < 0 then its a normal wait call if (sem->ceiling_prio < 0) { retval = ki_wait (sem, timeout); // could call k_wait but just extra fct call EI (); return retval; } if (pRun->prio < sem->ceiling_prio) { // I have higher priority than ceiling :-( EI (); return CEILINGFAIL; } // now we play imm ceiling protocol sem->saved_prio = pRun->prio; // do im ceiling pRun->prio = sem->ceiling_prio; // dont need to reinsert in AQ bq ceil prio is higher or equal to mine and Im already in front of AQ prio_enQ (pAQ, deQ (pRun)); // resinsert me in AQ acc to nwe(old) priority retval = ki_wait (sem, timeout); // coming back interrupt is still disabled ! // chk if we did get semaphore if (retval < 0) { // NOPE we did not pRun->prio = sem->saved_prio; // reset to my old priority prio_enQ (pAQ, deQ (pRun)); // reinsert me in AQ acc to nwe(old) priority ki_task_shift (); // bq maybe started task has higher prio than me } EI (); return retval; // 0(has waited),1(straight through) : ok, -1: timeout }
int ki_semval (struct k_t *sem) { DI (); return (sem->cnt1); }
int ki_signal (struct k_t *sem) { DI (); // just in case if (sem->cnt1 < sem->maxv) { sem->cnt1++; // Salute to Dijkstra if (sem->cnt1 <= 0) { sem->next->cnt2 = 0; // return code == ok prio_enQ (pAQ, deQ (sem->next)); return (0); // task was waiting } return (1); // just delivered a signal - no task was waiting } if (SEM_MAX_VALUE > sem->clip) { sem->clip++; } // here we are on bad clip failure no signal takes place // signal is lost !!! #ifdef KRNLBUG k_sem_clip (sem->nr, sem->clip); #endif return (-1); }
int ki_wait (struct k_t *sem, int timeout) { DI (); if (0 < sem->cnt1) { sem->cnt1--; // Salute to Dijkstra k_sem_unclip (sem->nr); return (1); // ok: 1 bq we are not suspended } if (timeout < 0) // no luck, dont want to wait so bye bye { return (-2); } // from here we want to wait pRun->cnt2 = timeout; // 0 == wait forever if (timeout) { // so we can be removed if timeout occurs pRun->cnt3 = (int) sem; // nasty keep ref to semaphore in task stomach } sem->cnt1--; // Salute to Dijkstra k_sem_unclip (sem->nr); enQ (sem, deQ (pRun)); ki_task_shift (); // back again - have semaphore received signal or timeout ? pRun->cnt3 = 0; // reset ref to timer semaphore return ((char) (pRun->cnt2)); // 0: ok , -1: timeout }
int main(int argc, char**argv) { int err; sqlite3 *conn; char *errmsg; err = sqlite3_open("test.sl3",&conn); Table *t = table_new(TableCsv | TableColumns); err = sqlite3_exec(conn,"select * from test", table_add_row,t,&errmsg); if (err) { printf("err '%s'\n",errmsg); return 1; } table_finish_rows(t); DUMPA(float,(float*)t->cols[1],"%f"); sqlite3_close(conn); unref(t); DI(obj_kount()); return 0; }
static void TxThread(void *arg) { int ThreadToWakeUp; while(1) { SleepThread(); if(PacketReqs.count > 0) { while(PacketReqs.count > 0) { WaitSema(NetManIOSemaID); while(SifCallRpc(&NETMAN_rpc_cd, NETMAN_IOP_RPC_FUNC_SEND_PACKETS, 0, &PacketReqs, sizeof(PacketReqs), &ReceiveBuffer, sizeof(ReceiveBuffer.result), &TxEndCallback, NULL) < 0){}; SignalSema(NetManIOSemaID); } } else { if(NetmanTxWaitingThread >= 0) { DI(); ThreadToWakeUp=NetmanTxWaitingThread; NetmanTxWaitingThread=-1; EI(); WakeupThread(ThreadToWakeUp); } } } }
/*********************************************************************************************************************** * Function Name: __low_level_init * Description : This function initializes hardware setting. * Arguments : None * Return Value : None ***********************************************************************************************************************/ int __low_level_init(void) { DI(); R_Systeminit(); return (1U); }
/*********************************************************************************************************************** * Function Name: HardwareSetup * Description : This function initializes hardware setting. * Arguments : None * Return Value : None ***********************************************************************************************************************/ int HardwareSetup(void) { DI(); R_Systeminit(); return (1U); }
char k_receive (struct k_msg_t *pB, void *el, int timeout, int *lost_msg) { int i; char *pSrc, *pDst; DI (); if (ki_wait (pB->sem, timeout) == 0) { // ki_wait bq then intr is not enabled when coming back pDst = (char *) el; pB->r++; pB->cnt--; // got one if (pB->nr_el <= pB->r) pB->r = 0; pSrc = pB->pBuf + pB->r * pB->el_size; for (i = 0; i < pB->el_size; i++) { *(pDst++) = *(pSrc++); } if (lost_msg) { *lost_msg = pB->lost_msg; pB->lost_msg = 0; } EI (); return (0); // yes } EI (); return (-1); // nothing for you my friend }
int k_wait (struct k_t *sem, int timeout) { // copy of ki_wait just with EI()'s before leaving DI (); if (0 < sem->cnt1) { // lucky that we do not need to wait ? sem->cnt1--; // Salute to Dijkstra EI (); return (0); } if (timeout == -1) { // no luck, dont want to wait so bye EI (); return (-2); } // from here we have to wait pRun->cnt2 = timeout; // if 0 then wait forever if (timeout) pRun->cnt3 = (int) sem; // nasty keep ref to semaphore, // so we can be removed if timeout occurs sem->cnt1--; // Salute to Dijkstra enQ (sem, deQ (pRun)); ki_task_shift (); // call enables interrupt on return EI (); return (char) (pRun->cnt2); // 0: ok, -1: timeout }
void k_reset () { DI (); wdt_enable (WDTO_15MS); while (1); }
/* * Free memory * It may be called during interrupt disable. In this case, need to wait * until interrupt is enabled and until free. */ EXPORT void knl_Ifree( void *ptr ) { QUEUE *aq; UINT imask; DI(imask); /* Exclusive control by interrupt disable */ aq = (QUEUE*)ptr - 1; clrAreaFlag(aq, AREA_USE); if ( !chkAreaFlag(aq->next, AREA_USE) ) { /* Merge with free area in after location */ knl_removeFreeQue(aq->next + 1); knl_removeAreaQue(aq->next); } if ( !chkAreaFlag(aq->prev, AREA_USE) ) { /* Merge with free area in front location */ aq = aq->prev; knl_removeFreeQue(aq + 1); knl_removeAreaQue(aq->next); } knl_appendFreeArea(knl_imacb, aq); EI(imask); }
int k_set_prio (char prio) { int i; if (!k_running) { return (-2); } DI (); if ((prio <= 0) || (DMY_PRIO <= prio)) // not legal value my friend { EI (); return (-1); } i = pRun->prio; pRun->prio = prio; prio_enQ (pAQ, deQ (pRun)); ki_task_shift (); EI (); return (i); }
unsigned char midi_out_send_standard_msg(unsigned char status, unsigned char data1, unsigned char data2) { unsigned char buffer_loc; if(msg_buffer_size < (MIDI_MSG_BUFFER_SIZE - 2)) { DI(); buffer_loc = (msg_buffer_current + msg_buffer_size) % MIDI_MSG_BUFFER_SIZE; midi_msg_buffer[buffer_loc] = status; msg_buffer_size++; buffer_loc = (msg_buffer_current + msg_buffer_size) % MIDI_MSG_BUFFER_SIZE; midi_msg_buffer[buffer_loc] = data1; msg_buffer_size++; buffer_loc = (msg_buffer_current + msg_buffer_size) % MIDI_MSG_BUFFER_SIZE; midi_msg_buffer[buffer_loc] = data2; msg_buffer_size++; //trigger the interrupt if already ready to transmit if((U1STAT0 & UART1_TRAN_RDY) && ((IRQ2SET & UART1_IRQ_EN) == 0)) { IRQ2SET |= UART1_IRQ_EN; } EI(); } else { return 1; } return 0; }
/** Initializes audsrv library @returns error code */ int audsrv_init() { int ret; if (initialized) { /* already done */ return 0; } memset(&cd0, '\0', sizeof(cd0)); while (1) { if (SifBindRpc(&cd0, AUDSRV_IRX, 0) < 0) { set_error(AUDSRV_ERR_RPC_FAILED); return -1; } if (cd0.server != 0) { break; } nopdelay(); } ee_sema_t compSema; compSema.init_count = 1; compSema.max_count = 1; compSema.option = 0; completion_sema = CreateSema(&compSema); if (completion_sema < 0) { set_error(AUDSRV_ERR_FAILED_TO_CREATE_SEMA); return -1; } SifCallRpc(&cd0, AUDSRV_INIT, 0, sbuff, 64, sbuff, 64, NULL, NULL); ret = sbuff[0]; if (ret != 0) { set_error(ret); return ret; } /* register a callback handler */ DI(); SifAddCmdHandler(AUDSRV_CDDA_CALLBACK, cdda_stopped, NULL); SifAddCmdHandler(AUDSRV_FILLBUF_CALLBACK, fillbuf_requested, NULL); EI(); /* initialize IOP heap (for adpcm samples) */ SifInitIopHeap(); set_error(AUDSRV_ERR_NOERROR); return AUDSRV_ERR_NOERROR; }
void DNF::setup_names() { if (pres_debug>=2) fprintf(DebugFile,"Setting up names for DNF 0x%p\n", this); for(DNF_Iterator DI(this); DI.live(); DI.next()) DI.curr()->setup_names(); }