static int watchdog_probe(struct platform_device *pdev) { wd_clk = clk_get(NULL, "watchdog"); BUG_ON(!wd_clk); clk_enable(wd_clk); spin_lock_init(&wdt_lock); /* watchdog can be disabled by providing either * "exynos4210_watchdog.sec_pet=0" or * "exynos4210_watchdog.sec_reset=0" to CMDLINE */ if (!watchdog_reset || !watchdog_pet) { clk_disable(wd_clk); return -ENODEV; } #if defined(PET_BY_WORKQUEUE) watchdog_wq = create_singlethread_workqueue("pet_watchdog"); watchdog_start(); #elif defined(PET_BY_DIRECT_TIMER) init_timer(&pet_watchdog_timer); pet_watchdog_timer.function = pet_watchdog_timer_fn; watchdog_start(); #else hrtimer_init(&watchdog_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); watchdog_timer.function = watchdog_timerfunc; watchdog_start(); #endif return 0; }
static int watchdog_open(struct inode *inode, struct file *file) { int err = -EBUSY; /* the watchdog is single open! */ if (test_and_set_bit(WDOG_DEV_OPEN, &wdd->status)) return -EBUSY; /* * If the /dev/watchdog device is open, we don't want the module * to be unloaded. */ if (!try_module_get(wdd->ops->owner)) goto out; err = watchdog_start(wdd); if (err < 0) goto out_mod; /* dev/watchdog is a virtual (and thus non-seekable) filesystem */ return nonseekable_open(inode, file); out_mod: module_put(wdd->ops->owner); out: clear_bit(WDOG_DEV_OPEN, &wdd->status); return err; }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(burn_process, ev, data) { PROCESS_BEGIN(); etimer_set(&etimer, 5*CLOCK_SECOND); PROCESS_WAIT_UNTIL(etimer_expired(&etimer)); watchdog_stop(); leds_on(LEDS_RED); #if NODEID printf("Burning node id %d\n", NODEID); node_id_burn(NODEID); leds_on(LEDS_BLUE); node_id_restore(); printf("Restored node id %d\n", node_id); #else #error "burn-nodeid must be compiled with nodeid=<the ID of the node>" node_id_restore(); printf("Restored node id %d\n", node_id); #endif leds_off(LEDS_RED + LEDS_BLUE); watchdog_start(); while(1) { PROCESS_WAIT_EVENT(); } PROCESS_END(); }
void AppColdStart(void) { /* default startup */ init_hardware(); buzzer_init(); rgb_leds_init(); sseg_init(); process_init(); init_net(); /* start the main processes */ procinit_init(); autostart_start(autostart_processes); jts_init(); /* enable watchdog on JN5148, there is none on JN5139 */ watchdog_start(); /* default main loop */ while(1) { process_run(); etimer_request_poll(); watchdog_periodic(); } }
void AppColdStart(void) { /* default startup */ init_hardware(); process_init(); procinit_init(); init_net(); jts_init(); /* application startup */ autostart_start(autostart_processes); /* enable watchdog on JN5148, there is none on JN5139 */ #ifdef __BA2__ watchdog_start(); #endif /* default main loop */ while(1) { process_run(); etimer_request_poll(); #ifdef __BA2__ watchdog_periodic(); #endif } }
/*---------------------------------------------------------------------------*/ int xmem_erase(long size, unsigned long addr) { unsigned long end = addr + size; if(size % XMEM_ERASE_UNIT_SIZE != 0) { PRINTF("xmem_erase: bad size\n"); return -1; } if(addr % XMEM_ERASE_UNIT_SIZE != 0) { PRINTF("xmem_erase: bad offset\n"); return -1; } watchdog_stop(); for (; addr < end; addr += XMEM_ERASE_UNIT_SIZE) { erase_sector(addr); } watchdog_start(); return size; }
static int watchdog_probe(struct platform_device *pdev) { watchdog_wq = alloc_workqueue("pet_watchdog", WQ_UNBOUND | WQ_HIGHPRI, 1); watchdog_start(); return 0; }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(shell_nodeid_process, ev, data) { uint16_t nodeid; char buf[20]; const char *newptr; PROCESS_BEGIN(); nodeid = shell_strtolong(data, &newptr); /* If no node ID was given on the command line, we print out the current channel. Else we burn the new node ID. */ if(newptr == data) { nodeid = node_id; } else { nodeid = shell_strtolong(data, &newptr); watchdog_stop(); leds_on(LEDS_RED); node_id_burn(nodeid); leds_on(LEDS_BLUE); node_id_restore(); leds_off(LEDS_RED + LEDS_BLUE); watchdog_start(); } snprintf(buf, sizeof(buf), "%d", nodeid); shell_output_str(&nodeid_command, "Node ID: ", buf); PROCESS_END(); }
/** * bmc_reset_watchdog is used for starting and restarting the watchdog * * \param rq pointer to request message * \param rs pointer to response message */ void bmc_reset_watchdog(ipmbMSG_t *rq, ipmbMSG_t *rs) { if (!wd_set) { /* the BMC watchdog timer is not initialized */ rs->data[0] = CC_SET_WDT_COMMAND_NOT_ISSUED; } /* only enable timer start if configured */ else { taskENTER_CRITICAL(); /* start or restart watchdog timer */ watchdog_start(); /* reset countdown value */ wd_timer.present_count = wd_timer.initial_count; /* delete pre timeout flag */ wd_timer.pretimeout_flag &= ~IPMB_WD_PRETO_FLAG; /* set wdt running */ wd_timer.timer_use |= WD_TIMER_START; taskEXIT_CRITICAL(); rs->data[0] = CC_COMPLETED_NORMALLY; } /* set response data length */ rs->data_len = 1; }
/*---------------------------------------------------------------------------*/ void flash_done(void) { /* Enable interrupts. */ SFRIE1 = sfrie; eint(); watchdog_start(); }
/*---------------------------------------------------------------------------*/ void flash_done(void) { /* Enable interrupts. */ IE1 = ie1; IE2 = ie2; _EINT(); watchdog_start(); }
/*---------------------------------------------------------------------------*/ static struct file * reserve(const char *name, coffee_page_t pages, int allow_duplicates, unsigned flags) { struct file_header hdr; coffee_page_t page; struct file *file; watchdog_stop(); if(!allow_duplicates && find_file(name) != NULL) { watchdog_start(); return NULL; } page = find_contiguous_pages(pages); if(page == INVALID_PAGE) { if(*gc_wait) { return NULL; } collect_garbage(GC_GREEDY); page = find_contiguous_pages(pages); if(page == INVALID_PAGE) { watchdog_start(); *gc_wait = 1; return NULL; } } memset(&hdr, 0, sizeof(hdr)); memcpy(hdr.name, name, sizeof(hdr.name) - 1); hdr.max_pages = pages; hdr.flags = HDR_FLAG_ALLOCATED | flags; write_header(&hdr, page); PRINTF("Coffee: Reserved %u pages starting from %u for file %s\n", pages, page, name); file = load_file(page, &hdr); file->end = 0; watchdog_start(); return file; }
int main() { const struct CMUnitTest tests[] = { cmocka_unit_test_setup_teardown(sysrepo_daemon_test, test_setup, test_teardown), }; watchdog_start(300); int ret = cmocka_run_group_tests(tests, NULL, NULL); watchdog_stop(); return ret; }
main(int unused_argc, char **unused_argv) { WATCHDOG *wp; msg_verbose = 1; wp = watchdog_create(10, (WATCHDOG_FN) 0, (char *) 0); watchdog_start(wp); do { watchdog_pat(); } while (VSTREAM_GETCHAR() != VSTREAM_EOF); watchdog_destroy(wp); }
/*---------------------------------------------------------------------------*/ void watchdog_reboot(void) { #if WATCHDOG_ENABLED == 1 watchdog_start(); if(MAP_WatchdogLockState(WATCHDOG0_BASE) == true) { MAP_WatchdogUnlock(WATCHDOG0_BASE); } MAP_WatchdogReloadSet(WATCHDOG0_BASE, (MAP_SysCtlClockGet() / 4)); // 250ms while(1); //loop #endif }
void initialize(void) { watchdog_init(); watchdog_start(); #if STACKMONITOR /* Simple stack pointer highwater monitor. Checks for magic numbers in the main * loop. In conjuction with TESTRTIMER, never-used stack will be printed * every STACKMONITOR seconds. */ { extern uint16_t __bss_end; uint16_t p=(uint16_t)&__bss_end; do { *(uint16_t *)p = 0x4242; p+=4; } while (p<SP-4); //don't overwrite our own stack } #endif /* rtimers needed for radio cycling */ rtimer_init(); rs232_init(RS232_PORT_0, BAUD_RATE(38400), USART_DATA_BITS_8 | USART_PARITY_NONE | USART_STOP_BITS_1); rs232_redirect_stdout(RS232_PORT_0); clock_init(); sei(); /* Initialize drivers and event kernel */ process_init(); led_init(); #if 0 procinit_init(); #else process_start(&etimer_process, NULL); process_start(&led_process, NULL); process_start(&led2_process, NULL); #endif PRINTA(CONTIKI_VERSION_STRING " started\r\n"); /* Comment this out if autostart_processes not defined at link */ /* Note AUTOSTART_PROCESSES(...) is only effective in the .co module */ autostart_start(autostart_processes); }
int main() { const struct CMUnitTest tests[] = { cmocka_unit_test_setup_teardown(cm_session_test, cm_setup, cm_teardown), cmocka_unit_test_setup_teardown(cm_session_neg_test, cm_setup, NULL), cmocka_unit_test_setup_teardown(cm_buffers_test, cm_setup, cm_teardown), cmocka_unit_test_setup_teardown(cm_signals_test, cm_setup, cm_teardown), }; watchdog_start(300); int ret = cmocka_run_group_tests(tests, NULL, NULL); watchdog_stop(); return ret; }
/*--------------------------------------------------------------------------*/ ISR(TIMER0_A1, rtimer_a01_isr) { /* store the IV register as any read/write resets interrupt flags */ uint16_t ivreg = TA0IV; if(ivreg & TA0IV_TACCR1) { /* rtimer interrupt */ TA0CCTL1 &= ~CCIFG; watchdog_start(); /* check for and run any pending rtimers */ rtimer_run_next(); /* also check for any pending events and wake up if needed */ if(process_nevents() > 0) { LPM4_EXIT; } watchdog_stop(); } else if(ivreg & TA0IV_TACCR2) { /* simple pwm interrupt */ TA0CCTL2 &= ~CCIFG; if(spwm.on_time > 0) { if(spwm.on_time == period) { TA0CCTL2 &= ~CCIE; /* no need for interrupt, is at 100% DC */ /* SIMPLE_PWM_PORT(OUT) |= (1 << spwm.pin);*/ pwm_on_cb(); } else { /* normal on-case */ if(period_end) { period_end = 0; TA0CCR2 = TAR + spwm.on_time; /* SIMPLE_PWM_PORT(OUT) |= (1 << spwm.pin);*/ pwm_off_cb(); } else { period_end = 1; TA0CCR2 = TAR + (period - spwm.on_time); /* SIMPLE_PWM_PORT(OUT) &= ~(1 << spwm.pin);*/ pwm_on_cb(); } } } } }
static void watchdog_workfunc(struct work_struct *work) { struct watchdog_data *wd; wd = container_of(work, struct watchdog_data, work.work); pr_debug("%s: pet watchdog\n", __func__); /* stop watchdog and restart it */ watchdog_stop(wd); watchdog_start(wd); /* reschedule to clear it again in the future */ queue_delayed_work(wd->wq, &wd->work, wd->pet_interval); }
timera0 (void) { ENERGEST_ON(ENERGEST_TYPE_IRQ); watchdog_start(); rtimer_run_next(); if(process_nevents() > 0) { LPM4_EXIT; } watchdog_stop(); ENERGEST_OFF(ENERGEST_TYPE_IRQ); }
/*---------------------------------------------------------------------------*/ ISR(TIMERA1, timera1) { ENERGEST_ON(ENERGEST_TYPE_IRQ); watchdog_start(); if(TAIV == 2) { /* HW timer bug fix: Interrupt handler called before TR==CCR. * Occurs when timer state is toggled between STOP and CONT. */ while(TACTL & MC1 && TACCR1 - TAR == 1); /* Make sure interrupt time is future */ do { TACCR1 += INTERVAL; ++count; /* Make sure the CLOCK_CONF_SECOND is a power of two, to ensure that the modulo operation below becomes a logical and and not an expensive divide. Algorithm from Wikipedia: http://en.wikipedia.org/wiki/Power_of_two */ #if (CLOCK_CONF_SECOND & (CLOCK_CONF_SECOND - 1)) != 0 #error CLOCK_CONF_SECOND must be a power of two (i.e., 1, 2, 4, 8, 16, 32, 64, ...). #error Change CLOCK_CONF_SECOND in contiki-conf.h. #endif if(count % CLOCK_CONF_SECOND == 0) { ++seconds; energest_flush(); } } while((TACCR1 - TAR) > INTERVAL); last_tar = TAR; if(etimer_pending() && (etimer_next_expiration_time() - count - 1) > MAX_TICKS) { etimer_request_poll(); LPM4_EXIT; } } /* if(process_nevents() >= 0) { LPM4_EXIT; }*/ watchdog_stop(); ENERGEST_OFF(ENERGEST_TYPE_IRQ); }
static int watchdog_open(struct inode *inode, struct file *file) { struct watchdog_core_data *wd_data; struct watchdog_device *wdd; bool hw_running; int err; /* Get the corresponding watchdog device */ if (imajor(inode) == MISC_MAJOR) wd_data = old_wd_data; else wd_data = container_of(inode->i_cdev, struct watchdog_core_data, cdev); /* the watchdog is single open! */ if (test_and_set_bit(_WDOG_DEV_OPEN, &wd_data->status)) return -EBUSY; wdd = wd_data->wdd; /* * If the /dev/watchdog device is open, we don't want the module * to be unloaded. */ hw_running = watchdog_hw_running(wdd); if (!hw_running && !try_module_get(wdd->ops->owner)) { err = -EBUSY; goto out_clear; } err = watchdog_start(wdd); if (err < 0) goto out_mod; file->private_data = wd_data; if (!hw_running) kref_get(&wd_data->kref); /* dev/watchdog is a virtual (and thus non-seekable) filesystem */ return stream_open(inode, file); out_mod: module_put(wd_data->wdd->ops->owner); out_clear: clear_bit(_WDOG_DEV_OPEN, &wd_data->status); return err; }
/*---------------------------------------------------------------------------*/ static void collect_garbage(int mode) { uint16_t sector; struct sector_status stats; coffee_page_t first_page, isolation_count; watchdog_stop(); PRINTF("Coffee: Running the file system garbage collector in %s mode\n", mode == GC_RELUCTANT ? "reluctant" : "greedy"); /* * The garbage collector erases as many sectors as possible. A sector is * erasable if there are only free or obsolete pages in it. */ for(sector = 0; sector < COFFEE_SECTOR_COUNT; sector++) { isolation_count = get_sector_status(sector, &stats); PRINTF("Coffee: Sector %u has %u active, %u obsolete, and %u free pages.\n", sector, (unsigned)stats.active, (unsigned)stats.obsolete, (unsigned)stats.free); if(stats.active > 0) { continue; } if((mode == GC_RELUCTANT && stats.free == 0) || (mode == GC_GREEDY && stats.obsolete > 0)) { first_page = sector * COFFEE_PAGES_PER_SECTOR; if(first_page < *next_free) { *next_free = first_page; } if(isolation_count > 0) { isolate_pages(first_page + COFFEE_PAGES_PER_SECTOR, isolation_count); } COFFEE_ERASE(sector); PRINTF("Coffee: Erased sector %d!\n", sector); if(mode == GC_RELUCTANT && isolation_count > 0) { break; } } } watchdog_start(); }
/*---------------------------------------------------------------------------*/ void LPTMR_IRQHandler(void) { ENERGEST_ON(ENERGEST_TYPE_IRQ); watchdog_start(); PRINTF("rtimer_arch_init compare event at 0x%4x.\n", rtimer_arch_now()); LPTMR0_CMR = LPTMR_CMR_COMPARE(LPTMR_CMR_COMPARE_MASK); LPTMR0_CSR = (uint32_t) ((LPTMR0_CSR & (uint32_t) ~(uint32_t) (LPTMR_CSR_TIE_MASK)) | (uint32_t) (LPTMR_CSR_TCF_MASK)); // Clear interrupt flag and disable interrupt rtimer_run_next(); watchdog_stop(); ENERGEST_OFF(ENERGEST_TYPE_IRQ); }
int main() { const struct CMUnitTest tests[] = { cmocka_unit_test(sr_new_tree_test), cmocka_unit_test(sr_new_trees_test), cmocka_unit_test(sr_node_set_name_test), cmocka_unit_test(sr_node_set_module_test), cmocka_unit_test(sr_node_set_str_data_test), cmocka_unit_test(sr_node_build_str_data_test), cmocka_unit_test(sr_node_add_child_test), cmocka_unit_test(sr_dup_tree_test), cmocka_unit_test(sr_dup_trees_test), cmocka_unit_test(sr_print_tree_test) }; watchdog_start(300); int ret = cmocka_run_group_tests(tests, NULL, NULL); watchdog_stop(); return ret; }
int start_watchdog(glite_renewal_core_context ctx, pid_t *pid) { pid_t p; switch ((p = fork())) { case -1: edg_wlpr_Log(ctx, LOG_ERR, "fork() failed: %s", strerror(errno)); return errno; case 0: watchdog_start(ctx); exit(0); break; default: *pid = p; return 0; } /* not reachable */ exit(0); }
static int watchdog_open(struct inode *inode, struct file *file) { int err = -EBUSY; struct watchdog_device *wdd; /* Get the corresponding watchdog device */ if (imajor(inode) == MISC_MAJOR) wdd = old_wdd; else wdd = container_of(inode->i_cdev, struct watchdog_device, cdev); /* the watchdog is single open! */ if (test_and_set_bit(WDOG_DEV_OPEN, &wdd->status)) return -EBUSY; /* * If the /dev/watchdog device is open, we don't want the module * to be unloaded. */ if (!try_module_get(wdd->ops->owner)) goto out; err = watchdog_start(wdd); if (err < 0) goto out_mod; file->private_data = wdd; if (wdd->ops->ref) wdd->ops->ref(wdd); /* dev/watchdog is a virtual (and thus non-seekable) filesystem */ return nonseekable_open(inode, file); out_mod: module_put(wdd->ops->owner); out: clear_bit(WDOG_DEV_OPEN, &wdd->status); return err; }
/** * start wdt internal * * \param mode watchdog mode * \param action action * \param count countdown value */ void bmc_start_wd_timer(unsigned char use, unsigned char action, unsigned short count) { if (!(wd_timer.timer_use & WD_TIMER_START)) { taskENTER_CRITICAL(); /* set watchdog timer values */ wd_timer.timer_use = use; wd_timer.timer_action = action; wd_timer.initial_count = count; wd_timer.present_count = count; wd_timer.timer_use |= WD_TIMER_START; /* start or restart watchdog timer */ watchdog_start(); taskEXIT_CRITICAL(); #ifdef CFG_CPCI wd_set = 1; #endif } }
void MXBMESH::begin(channel_t chan,uint16_t localaddress,HardwareSerial *mySerial,bool powermode) { #if WITHSINKSOFT sinkSerial=mySerial; #endif NODEINFO.localAddress=localaddress; NODEINFO.localChannel=chan; NODEINFO.islowpower=powermode; MxTimer2::set(TIMER2TICKS*1000, timer2function); // call every 30s for broadcast ,resolution must >=1000 MxTimer2::start(); if (NODEINFO.LoadCONFIG()) //maybe restart { MxRadio.begin(NODEINFO.localChannel,0xffff,NODEINFO.localAddress,true,true,true,15); MxRadio.setParam(phyTransmitPower,(txpwr_t)(NODEINFO.txPower-TXPOWERSHIFT)); } else { NODEINFO.SaveCONFIG(); MxRadio.begin(NODEINFO.localChannel,0xffff,NODEINFO.localAddress,true,true,true,15); } randomSeed(NODEINFO.localAddress); MxRadio.attachReceiveFrame(recievehandler); //MxRadio.attachError(errHandle); MxRadio.attachTxDone(onXmitDone); for (int nbindex=0;nbindex<MAX_NB;nbindex++) { NODEINFO.neigbour[nbindex].nodeid=BROADCASTADDR; } rxqueue.init_queue(); txqueue.init_queue(); if (NODEINFO.dataupload_interval==0xffff) NODEINFO.dataupload_interval=0; watchdog_init(); watchdog_start(); }
/*---------------------------------------------------------------------------*/ PROCESS_THREAD(preload_process, ev, data) { PROCESS_BEGIN(); etimer_set(&etimer, 5 * CLOCK_SECOND); PROCESS_WAIT_UNTIL(etimer_expired(&etimer)); watchdog_stop(); leds_on(LEDS_RED); preload(); leds_on(LEDS_BLUE); printf("done\n"); leds_off(LEDS_RED + LEDS_BLUE); watchdog_start(); while(1) { PROCESS_WAIT_EVENT(); } PROCESS_END(); }