/* * This routine creates a new partition map and sets it current. If there * was a current map, the new map starts out identical to it. Otherwise * the new map starts out all zeroes. */ void make_partition() { register struct partition_info *pptr, *parts; int i; /* * Lock out interrupts so the lists don't get mangled. */ enter_critical(); /* * Get space for for the new map and link it into the list * of maps for the current disk type. */ pptr = (struct partition_info *)zalloc(sizeof (struct partition_info)); parts = cur_dtype->dtype_plist; if (parts == NULL) { cur_dtype->dtype_plist = pptr; } else { while (parts->pinfo_next != NULL) { parts = parts->pinfo_next; } parts->pinfo_next = pptr; pptr->pinfo_next = NULL; } /* * If there was a current map, copy its values. */ if (cur_label == L_TYPE_EFI) { struct dk_gpt *map; int nparts; int size; nparts = cur_parts->etoc->efi_nparts; size = sizeof (struct dk_part) * nparts + sizeof (struct dk_gpt); map = zalloc(size); (void) memcpy(map, cur_parts->etoc, size); pptr->etoc = map; cur_disk->disk_parts = cur_parts = pptr; exit_critical(); return; } if (cur_parts != NULL) { for (i = 0; i < NDKMAP; i++) { pptr->pinfo_map[i] = cur_parts->pinfo_map[i]; } pptr->vtoc = cur_parts->vtoc; } else { /* * Otherwise set initial default vtoc values */ set_vtoc_defaults(pptr); } /* * Make the new one current. */ cur_disk->disk_parts = cur_parts = pptr; exit_critical(); }
void TASK_stop_timer(task_timer* timer) { #ifndef CONFIG_TASK_NONCRITICAL_TIMER enter_critical(); TQ_ENTER_CRITICAL; #endif if (!timer->alive) { #ifndef CONFIG_TASK_NONCRITICAL_TIMER TQ_EXIT_CRITICAL; exit_critical(); #endif return; } task_sys.tim_lock = TRUE; timer->alive = FALSE; // wipe all dead instances task_timer *cur_timer = task_sys.first_timer; task_timer *pre_timer = NULL; while (cur_timer) { if (cur_timer->alive == FALSE) { if (pre_timer == NULL) { task_sys.first_timer = timer->_next; } else { pre_timer->_next = timer->_next; } } pre_timer = cur_timer; cur_timer = cur_timer->_next; } task_sys.tim_lock = FALSE; #ifndef CONFIG_TASK_NONCRITICAL_TIMER TQ_EXIT_CRITICAL; exit_critical(); #endif }
void free_mem(struct os_mem *mem_ptr, void *block_ptr) { cpsr_t cpsr; if (mem_ptr == NULL) return; if (block_ptr == NULL) return; enter_critical(); /* Make sure all blocks not already returned */ if (mem_ptr->num_free >= mem_ptr->num_blocks) { exit_critical(); return; } /* block_ptr point to the next free block address */ //*(void **) block_ptr = mem_ptr->mem_free_list; //mem_ptr->mem_free_list = block_ptr; void *free_block; int return_blocks = 0; void **link_ptr; /* free block address */ free_block = mem_ptr->mem_free_list; mem_ptr->mem_free_list = block_ptr; link_ptr = mem_ptr->mem_free_list; /* Link the block address back to list */ while (TRUE) { block_ptr += mem_ptr->block_len; if (block_ptr == free_block) break; *link_ptr = block_ptr; link_ptr = (void **) block_ptr; ++return_blocks; } mem_ptr->num_free += return_blocks + 1; exit_critical(); }
static void stmpe_task_adc(u32_t a, void *b) { enter_critical(); if (!TASK_mutex_lock(&i2c_mutex)) { STMPE_DBG("stmpe_impl task adc mutex locked\n"); exit_critical(); return; } STMPE_DBG("stmpe_impl task adc mutex acquired\n"); int res = stmpe811_handler_adc_read(&stmpe.handler, stmpe.adc_chan); if (res != I2C_OK) { STMPE_DBG("stmpe_impl task adc ERR mutex unlocked\n"); TASK_mutex_unlock(&i2c_mutex); } exit_critical(); }
static void stmpe_task_gpio(u32_t a, void *b) { enter_critical(); if (!TASK_mutex_lock(&i2c_mutex)) { STMPE_DBG("stmpe_impl task gpio mutex locked\n"); exit_critical(); return; } STMPE_DBG("stmpe_impl task gpio mutex acquired\n"); int res = stmpe811_handler_gpio_define(&stmpe.handler, stmpe.gpio_set, stmpe.gpio_reset); if (res != I2C_OK) { STMPE_DBG("stmpe_impl task gpio ERR mutex unlocked\n"); TASK_mutex_unlock(&i2c_mutex); } exit_critical(); }
static void stmpe_err_cb(stmpe811_handler_state state, int err) { enter_critical(); if (err) DBG(D_APP, D_WARN, "stmpe_impl callback state:%i res:%i\n", state, err); STMPE_DBG("stmpe_impl res state:%i res:%i\n", state, err); STMPE_DBG("stmpe_impl finished mutex unlocked\n"); TASK_mutex_unlock(&i2c_mutex); if (err) { stmpe.req_mask = 0; } // the order must comply with stmpe_exe_req function order if (state == STMPE811_HDL_STATE_GPIO_DEFINE_CLR || state == STMPE811_HDL_STATE_GPIO_DEFINE_SET) { STMPE_DBG("stmpe_impl req CLR gpio\n"); stmpe.req_mask &= ~STMPE_REQ_GPIO; stmpe.gpio_set = 0; stmpe.gpio_reset = 0; } else if (state == STMPE811_HDL_STATE_ADC_READ) { STMPE_DBG("stmpe_impl req CLR adc\n"); stmpe.req_mask &= ~STMPE_REQ_ADC; stmpe.adc_chan = 0; } else if (state == STMPE811_HDL_STATE_TEMP_READ || state == STMPE811_HDL_STATE_TEMP_RESULT) { STMPE_DBG("stmpe_impl req CLR temp\n"); stmpe.req_mask &= ~STMPE_REQ_TEMP; } else if (state == STMPE811_HDL_STATE_INT_STA_READ) { STMPE_DBG("stmpe_impl req CLR int_sta\n"); print("int sta 0b%08b\n", stmpe811_handler_int_sta_get(&stmpe.handler)); stmpe.req_mask &= ~STMPE_REQ_INT_STA; } stmpe_exe_req(); exit_critical(); }
static int init_task_struct(struct task_struct *task, u32 flag) { struct task_struct *parent; unsigned long flags; /* if thread is a kernel thread, his parent is idle */ if (flag & PROCESS_TYPE_KERNEL) parent = idle; else parent = current; /* get a new pid */ task->pid = get_new_pid(task); if ((task->pid) < 0) return -EINVAL; task->uid = parent->uid; task->stack_base = NULL; task->stack_base = NULL; strncpy(task->name, parent->name, PROCESS_NAME_SIZE); task->flag = flag; task->state = 0; /* add task to the child list of his parent. */ task->parent = parent; init_list(&task->p); init_list(&task->child); init_mutex(&task->mutex); enter_critical(&flags); list_add(&parent->child, &task->p); exit_critical(&flags); return 0; }
int p_expand() { uint64_t delta; uint_t nparts; struct dk_gpt *efi_label = cur_parts->etoc; if (cur_parts->etoc->efi_altern_lba == 1 || (cur_parts->etoc->efi_altern_lba >= cur_parts->etoc->efi_last_lba)) { err_print("Warning: No expanded capacity is found.\n"); return (0); } delta = efi_label->efi_last_lba - efi_label->efi_altern_lba; nparts = efi_label->efi_nparts; enter_critical(); efi_label->efi_parts[nparts - 1].p_start += delta; efi_label->efi_last_u_lba += delta; efi_label->efi_altern_lba = cur_parts->etoc->efi_last_lba; exit_critical(); fmt_print("The expanded capacity is added to the unallocated space.\n"); return (0); }
void * get_mem(struct os_mem *mem_ptr, u32 size) { cpsr_t cpsr; void *block_ptr; if (mem_ptr == NULL) { errno = ERR_MEM_INVALID_PTR; return NULL; } enter_critical(); /* // See if there any free memory blocks if (mem_ptr->num_free > 0) { // Point to the start free block block_ptr = mem_ptr->mem_free_list; // mem_free_list = next block addr mem_ptr->mem_free_list = *(void **) block_ptr; --(mem_ptr->num_free); exit_critical(); return block_ptr; } */ /**/ int need_blocks; need_blocks = (int) (size / mem_ptr->block_len) + 1; if (mem_ptr->num_free > need_blocks) { /* Point to the start free block */ block_ptr = mem_ptr->mem_free_list; /* mem_free_list = next n blocks addr */ mem_ptr->mem_free_list = *(void **) ((u8 *) block_ptr + \ (need_blocks - 1) * mem_ptr->block_len); mem_ptr->num_free -= need_blocks; exit_critical(); return block_ptr; } exit_critical(); errno = ERR_MEM_NO_FREE_BLOCK; return NULL; }
void spin_unlock_irqstore(spin_lock_t *lock, unsigned long *flags) { #ifdef CONFIG_SMP lock->value = 0; lock->cpu = -1; #endif exit_critical(flags); }
bool TASK_mutex_lock(task_mutex *m) { task *t = task_sys.current; if (!m->taken) { m->entries = 1; task_take_lock(t, m); TRACE_TASK_MUTEX_ENTER(t->_ix); return TRUE; } if (m->reentrant && m->owner == t) { m->entries++; TRACE_TASK_MUTEX_ENTER_M(t->_ix); ASSERT(m->entries < 254); return TRUE; } // taken, mark task still allocated and insert into mutexq TRACE_TASK_MUTEX_WAIT(t->_ix); enter_critical(); TQ_ENTER_CRITICAL; t->wait_mutex = m; if ((t->flags & (TASK_STATIC | TASK_LOOP)) == 0) { task_pool.mask[t->_ix/32] &= ~(1<<(t->_ix & 0x1f)); } if ((t->flags & TASK_LOOP)) { // looped, remove us from end of queue ASSERT(task_sys.last == t); ASSERT(task_sys.head); if (task_sys.head == t) { // the only task in sched queue task_sys.head = NULL; task_sys.last = NULL; } else { // find the task pointing to the last task == current task task *ct = (task *)task_sys.head; while (ct->_next != t) { ct = ct->_next; ASSERT(ct); } // remove last task from queue ct->_next = NULL; task_sys.last = ct; } } TQ_EXIT_CRITICAL; exit_critical(); // insert into mutex queue if (m->last == 0) { m->head = t; } else { m->last->_next = t; } m->last = t; t->_next = NULL; t->flags &= ~TASK_RUN; t->flags |= TASK_WAIT; return FALSE; }
static void idle_task(void *parg) { while(true) { exit_critical(); yield(); } //asm volatile("pwrsav #1"); }
void STMPE_req_read_int_sta(void) { enter_critical(); bool do_req = stmpe.req_mask == 0; stmpe.req_mask |= STMPE_REQ_INT_STA; if (do_req) { stmpe_exe_req(); } exit_critical(); }
void STMPE_req_read_temp(void) { enter_critical(); bool do_req = stmpe.req_mask == 0; stmpe.req_mask |= STMPE_REQ_TEMP; if (do_req) { stmpe_exe_req(); } exit_critical(); }
/* * This routine picks to closest partition table which matches the * selected disk type. It is called each time the disk type is * changed. If no match is found, it uses the first element * of the partition table. If no table exists, a dummy is * created. */ int get_partition() { register struct partition_info *pptr; register struct partition_info *parts; /* * If there are no pre-defined maps for this disk type, it's * an error. */ parts = cur_dtype->dtype_plist; if (parts == NULL) { err_print("No defined partition tables.\n"); make_partition(); return (-1); } /* * Loop through the pre-defined maps searching for one which match * disk type. If found copy it into unmamed partition. */ enter_critical(); for (pptr = parts; pptr != NULL; pptr = pptr->pinfo_next) { if (cur_dtype->dtype_asciilabel) { if (pptr->pinfo_name != NULL && strcmp(pptr->pinfo_name, cur_dtype->dtype_asciilabel) == 0) { /* * Set current partition and name it. */ cur_disk->disk_parts = cur_parts = pptr; cur_parts->pinfo_name = pptr->pinfo_name; exit_critical(); return (0); } } } /* * If we couldn't find a match, take the first one. * Set current partition and name it. */ cur_disk->disk_parts = cur_parts = cur_dtype->dtype_plist; cur_parts->pinfo_name = parts->pinfo_name; exit_critical(); return (0); }
int thr_sigsetmask(int how, const sigset_t *set, sigset_t *oset) { ulwp_t *self = curthread; sigset_t saveset; if (set == NULL) { enter_critical(self); if (oset != NULL) *oset = self->ul_sigmask; exit_critical(self); } else { switch (how) { case SIG_BLOCK: case SIG_UNBLOCK: case SIG_SETMASK: break; default: return (EINVAL); } /* * The assignments to self->ul_sigmask must be protected from * signals. The nuances of this code are subtle. Be careful. */ block_all_signals(self); if (oset != NULL) saveset = self->ul_sigmask; switch (how) { case SIG_BLOCK: self->ul_sigmask.__sigbits[0] |= set->__sigbits[0]; self->ul_sigmask.__sigbits[1] |= set->__sigbits[1]; self->ul_sigmask.__sigbits[2] |= set->__sigbits[2]; self->ul_sigmask.__sigbits[3] |= set->__sigbits[3]; break; case SIG_UNBLOCK: self->ul_sigmask.__sigbits[0] &= ~set->__sigbits[0]; self->ul_sigmask.__sigbits[1] &= ~set->__sigbits[1]; self->ul_sigmask.__sigbits[2] &= ~set->__sigbits[2]; self->ul_sigmask.__sigbits[3] &= ~set->__sigbits[3]; break; case SIG_SETMASK: self->ul_sigmask.__sigbits[0] = set->__sigbits[0]; self->ul_sigmask.__sigbits[1] = set->__sigbits[1]; self->ul_sigmask.__sigbits[2] = set->__sigbits[2]; self->ul_sigmask.__sigbits[3] = set->__sigbits[3]; break; } delete_reserved_signals(&self->ul_sigmask); if (oset != NULL) *oset = saveset; restore_signals(self); } return (0); }
void STMPE_req_gpio_set(u8_t set, u8_t reset) { enter_critical(); bool do_req = stmpe.req_mask == 0; stmpe.gpio_set |= set; stmpe.gpio_reset |= reset; stmpe.req_mask |= STMPE_REQ_GPIO; if (do_req) { stmpe_exe_req(); } exit_critical(); }
void STMPE_req_read_adc(u8_t adc, adc_cb_f fn) { enter_critical(); bool do_req = stmpe.req_mask == 0; stmpe.adc_chan = adc; stmpe.req_mask |= STMPE_REQ_ADC; stmpe.adc_cb = fn; if (do_req) { stmpe_exe_req(); } exit_critical(); }
/**********************************************************************//** * \brief MCLK, SMCLK, and ACLK Init Routine * * This function uses REFO (the internal reference oscillator) to initialize * the DCO to the value targetFreq * * \retval -1 The clock initialization failed * \retval 0 The clock initialization was successful * *************************************************************************/ int clkInit(void) { unsigned int state; long retval; enter_critical(state); retval = setFLL(DCO_FREQ); exit_critical(state); if(retval != -1) retval = 0; return (int)retval; }
/* * Tell the kernel to block all signals. * Use the schedctl interface, or failing that, use __lwp_sigmask(). * This action can be rescinded only by making a system call that * sets the signal mask: * __lwp_sigmask(), __sigprocmask(), __setcontext(), * __sigsuspend() or __pollsys(). * In particular, this action cannot be reversed by assigning * scp->sc_sigblock = 0. That would be a way to lose signals. * See the definition of restore_signals(self). */ void block_all_signals(ulwp_t *self) { volatile sc_shared_t *scp; enter_critical(self); if ((scp = self->ul_schedctl) != NULL || (scp = setup_schedctl()) != NULL) scp->sc_sigblock = 1; else (void) __lwp_sigmask(SIG_SETMASK, &maskset); exit_critical(self); }
/*********************************************************** *功能: 初始化调试功能 *形参: * 无 *返回: * 无 */ void InitDebug(void) { //Initbutten(); //按键 //oled enter_critical(); OLED_Init(); exit_critical(); //串口 uart_init(Debug_UARTx, 115200); uart_irq_EN(Debug_UARTx); gpio_Interrupt_init(DEBUG_PIN, GPI_UP_PF, GPI_DISAB); }
int register_irq(int nr,int (*fn)(void *arg),void *arg) { int err = 0; unsigned long flags; if ((nr > IRQ_NR-1) || (fn == NULL)) return -EINVAL; enter_critical(&flags); err = arch_register_irq(nr, fn, arg); exit_critical(&flags); return err; }
task* TASK_create(task_f f, u8_t flags) { enter_critical(); TQ_ENTER_CRITICAL; task* task = TASK_snatch_free(flags & TASK_STATIC); TQ_EXIT_CRITICAL; exit_critical(); if (task) { task->f = f; task->run_requests = 0; task->flags = flags & (~(TASK_RUN | TASK_EXE | TASK_WAIT | TASK_KILLED)); return task; } else { return 0; } }
static void stmpe_task_config(u32_t a, void *b) { enter_critical(); if (!TASK_mutex_lock(&i2c_mutex)) { STMPE_DBG("stmpe_impl task config mutex locked\n"); exit_critical(); return; } STMPE_DBG("stmpe_impl task config mutex acquired\n"); int res = stmpe811_handler_setup(&stmpe.handler, STMPE_BLOCK_TEMP | STMPE_BLOCK_GPIO | STMPE_BLOCK_ADC, STMPE_GPIO_VBAT_EN | STMPE_GPIO2 | STMPE_GPIO3 | STMPE_GPIO4 | STMPE_GPIO5 | STMPE_GPIO6 | STMPE_GPIO7, // analog / digital STMPE_GPIO_VBAT_EN, // direction 0, // default output TRUE, // interrupt STMPE_INT_POLARITY_ACTIVE_LOW_FALLING, STMPE_INT_TYPE_LEVEL, // interrupt config STMPE_INT_GPIO | STMPE_INT_ADC | STMPE_INT_TEMP_SENS, // interrupt enable STMPE_GPIO2 | STMPE_GPIO3 | STMPE_GPIO4 | STMPE_GPIO5 | STMPE_GPIO6 | STMPE_GPIO7, // gpio interrupt mask STMPE_GPIO_ADC_VBAT, // adc interrupt mask STMPE_GPIO2 | STMPE_GPIO3 | STMPE_GPIO4 | STMPE_GPIO5 | STMPE_GPIO6 | STMPE_GPIO7, // detect rising STMPE_GPIO2 | STMPE_GPIO3 | STMPE_GPIO4 | STMPE_GPIO5 | STMPE_GPIO6 | STMPE_GPIO7, // detect falling STMPE_ADC_CLK_3_25MHZ, STMPE_ADC_TIM_80, STMPE_ADC_RES_12B, STMPE_ADC_REF_INT, TRUE, // temp enable STMPE_TEMP_MODE_ONCE, FALSE, STMPE_TEMP_THRES_OVER, 0); if (res != I2C_OK) { STMPE_DBG("stmpe_impl task config ERR mutex unlocked\n"); TASK_mutex_unlock(&i2c_mutex); } exit_critical(); }
void TASK_free(task *t) { enter_critical(); TQ_ENTER_CRITICAL; if ((t->flags & TASK_RUN) == 0) { // not scheduled, so remove it directly from pool task_pool.mask[t->_ix/32] |= (1<<(t->_ix & 0x1f)); } // else, scheduled => will be removed in TASK_tick when executed #ifdef CONFIG_TASKQ_MUTEX // check if task is in a mutex wait queue, and remove it if so if (t->flags & TASK_WAIT) { ASSERT(t->wait_mutex); task_mutex *m = t->wait_mutex; if (m->head == t) { m->head = t->_next; if (m->last == t) { m->last = NULL; } } else { task *prev_ct = NULL; task *ct = (task *)m->head; while (ct != NULL) { if (ct == t) { ASSERT(prev_ct); prev_ct->_next = t->_next; if (m->last == t) { m->last = prev_ct; prev_ct->_next = NULL; } break; } prev_ct = ct; ct = ct->_next; } } } #endif t->flags &= ~(TASK_RUN | TASK_STATIC | TASK_LOOP | TASK_WAIT); t->flags |= TASK_KILLED; TQ_EXIT_CRITICAL; exit_critical(); }
result_t subscribe(msg_hook_t *handler) { if(handler == 0) return e_bad_parameter; enter_critical(); if(listener != 0) { listener->prev = handler; handler->next = listener; } listener = handler; exit_critical(); return s_ok; }
result_t register_service(uint8_t service, msg_hook_t *handler) { if(service == 0 || service >= num_services) return e_bad_parameter; enter_critical(); if(services[service] != 0) { handler->prev = services[service]; handler->prev->next = handler; } services[service] = handler; exit_critical(); return s_ok; }
result_t unsubscribe(msg_hook_t *handler) { enter_critical(); if(handler->prev != 0) handler->prev->next = handler->next; if(handler->next != 0) handler->next->prev = handler->prev; if(handler == listener) listener = handler->next; handler->next = 0; handler->prev = 0; exit_critical(); return s_ok; }
void TASK_run(task* task, u32_t arg, void* arg_p) { ASSERT(task); ASSERT((task_pool.mask[task->_ix/32] & (1<<(task->_ix & 0x1f))) == 0); // check it is allocated ASSERT((task->flags & TASK_RUN) == 0); // already scheduled ASSERT((task->flags & TASK_WAIT) == 0); // waiting for a mutex ASSERT(task >= &task_pool.task[0]); // mem check ASSERT(task <= &task_pool.task[CONFIG_TASK_POOL]); // mem check task->flags |= TASK_RUN; task->arg = arg; task->arg_p = arg_p; enter_critical(); TQ_ENTER_CRITICAL; if (task_sys.last == 0) { task_sys.head = task; } else { task_sys.last->_next = task; } task_sys.last = task; // would same task be added twice or more, this at least fixes endless loop task->_next = 0; task->run_requests++; // if added again during execution TRACE_TASK_RUN(task->_ix); #if defined(CONFIG_OS) & defined(CONFIG_TASK_QUEUE_IN_THREAD) //#if defined(CONFIG_OS) // TODO PETER FIX // for some reason we sporadically crash when doing OS_cond_sig // whilst firing off tasks in IRQs which occur very frequently // (eg dumping pics from ADNS3000s) - only when task queue is not in // a thread. Fix is to put task queue in a thread or not signalling // the condition, but need to sort out why this happens. // // hardfault: // INVPC: UsaFlt general // FORCED: HardFlt SVC/BKPT within SVC OS_cond_signal(&task_sys.cond); #endif TQ_EXIT_CRITICAL; exit_critical(); }
/* * Report a thread usage error. * Not called if _THREAD_ERROR_DETECTION=0. * Writes message and continues execution if _THREAD_ERROR_DETECTION=1. * Writes message and dumps core if _THREAD_ERROR_DETECTION=2. */ void thread_error(const char *msg) { char buf[800]; uberdata_t *udp; ulwp_t *self; lwpid_t lwpid; /* avoid recursion deadlock */ if ((self = __curthread()) != NULL) { if (assert_thread == self) _exit(127); enter_critical(self); (void) _lwp_mutex_lock(&assert_lock); assert_thread = self; lwpid = self->ul_lwpid; udp = self->ul_uberdata; } else { self = NULL; (void) _lwp_mutex_lock(&assert_lock); lwpid = _lwp_self(); udp = &__uberdata; } (void) strcpy(buf, "\n*** _THREAD_ERROR_DETECTION: " "thread usage error detected ***\n*** "); (void) strcat(buf, msg); (void) strcat(buf, "\n*** calling thread is "); ultos((uint64_t)(uintptr_t)self, 16, buf + strlen(buf)); (void) strcat(buf, " thread-id "); ultos((uint64_t)lwpid, 10, buf + strlen(buf)); (void) strcat(buf, "\n\n"); (void) __write(2, buf, strlen(buf)); if (udp->uberflags.uf_thread_error_detection >= 2) Abort(buf); assert_thread = NULL; (void) _lwp_mutex_unlock(&assert_lock); if (self != NULL) exit_critical(self); }