void openwsn_init() { // drivers openserial_init(); // stack // cross-layer idmanager_init(); // call first since initializes e.g. EUI64 openqueue_init(); openrandom_init(); opentimers_init(); // 02a-TSCH ieee154e_init(); // 02b-RES schedule_init(); res_init(); neighbors_init(); nf_init(); //noise floor module // 03a-IPHC openbridge_init(); iphc_init(); // 03b-IPv6 forwarding_init(); icmpv6_init(); icmpv6echo_init(); icmpv6router_init(); icmpv6rpl_init(); // 04-TRAN opentcp_init(); openudp_init(); opencoap_init(); // initialize before any of the CoAP clients // 07-App //--CoAP //rwellknown_init(); //rreg_init(); //rinfo_init(); //rleds_init(); //rt_init(); //rex_init(); //rheli_init(); //rrube_init(); //rxl1_init(); //layerdebug_init(); //--UDP /*udpecho_init(); udpinject_init(); udpprint_init();*/ //udprand_init(); //udpstorm_init(); //--TCP /*ohlone_init(); tcpecho_init(); tcpinject_init(); tcpprint_init();*/ //--misc //heli_init(); //imu_init(); //bbk_init(); //hdl_init(); }
void openstack_init(void) { //===== drivers openserial_init(); //===== stack //-- cross-layer idmanager_init(); // call first since initializes EUI64 and isDAGroot openqueue_init(); openrandom_init(); opentimers_init(); //-- 02a-TSCH adaptive_sync_init(); ieee154e_init(); //-- 02b-RES schedule_init(); sixtop_init(); neighbors_init(); //===== applications openapps_init(); openserial_printInfo( COMPONENT_OPENWSN,ERR_BOOTED, (errorparameter_t)0, (errorparameter_t)0 ); }
void setup_software(void){ /********************************************* * Scheduler Initialization. Do not modify. * *********************************************/ schedule_init(schedule,SCHEDULE_TICK_DIVIDER,SCHEDULE_TICKS_PER_MS); /********************************************* * Put user initialization code below here. * *********************************************/ set_heartbeat_period_ms(250); //initialize SSP ring buffer can_ring_init(&csr_ssp_tx_ring,csr_ssp_tx_frame_buf,CSR_SSP_TX_FRAME_BUF_LEN); //SSP main transmit ring buffer csr_ssp_tx_ring_ptr_set(&csr_ssp_tx_ring); //initialize CAN ring buffers can_ring_init(&rx_ring,rx_frame_buf,RX_FRAME_BUF_LEN); can_rx_set_chan_cfg(CHAN_CAN1, (volatile unsigned long *)0xE0044000, &rx_ring, CAN_DISPATCH_MANUAL); //CAN controller 1 can_rx_set_chan_cfg(CHAN_CAN2, (volatile unsigned long *)0xE0048000, &rx_ring, CAN_DISPATCH_MANUAL); //CAN controller 2 can_rx_set_chan_cfg(CHAN_CAN3, (volatile unsigned long *)0xE004C000, &rx_ring, CAN_DISPATCH_MANUAL); //CAN controller 3 can_rx_set_chan_cfg(CHAN_CAN4, (volatile unsigned long *)0xE0050000, &rx_ring, CAN_DISPATCH_MANUAL); //CAN controller 4 can_ring_init(&tx1_ring,tx1_frame_buf,TX_FRAME_BUF_LEN); //CAN controller 1 transmit can_ring_init(&tx2_ring,tx2_frame_buf,TX_FRAME_BUF_LEN); //CAN controller 2 transmit can_ring_init(&tx3_ring,tx3_frame_buf,TX_FRAME_BUF_LEN); //CAN controller 3 transmit can_ring_init(&tx4_ring,tx4_frame_buf,TX_FRAME_BUF_LEN); //CAN controller 4 transmit can_tx_set_chan_cfg(CHAN_CAN1, (volatile unsigned long *)0xE0044000, &tx1_ring); //CAN controller 1 can_tx_set_chan_cfg(CHAN_CAN2, (volatile unsigned long *)0xE0048000, &tx2_ring); //CAN controller 2 can_tx_set_chan_cfg(CHAN_CAN3, (volatile unsigned long *)0xE004C000, &tx3_ring); //CAN controller 3 can_tx_set_chan_cfg(CHAN_CAN4, (volatile unsigned long *)0xE0050000, &tx4_ring); //CAN controller 4 //////////////////////////////////////////////////////////////////// //Enable interrupts //////////////////////////////////////////////////////////////////// //Timer0 interrupt setup VICVectAddr0 = (unsigned long)timer0_isr; VICVectCntl0 = 0x20 | 4; /* Timer1 Interrupt */ VICIntEnable = 1 << 4; /* Enable Timer1 Interrupt */ /* //SSP interrupt setup IRQ VICVectAddr2 = (unsigned long)csr_ssp_isr; VICVectCntl2 = 0x20 | 11; // SSP Interrupt, set to level 2 VICIntEnable = 1 << 11; // Enable SSP interrupt */ //SSP interrupt setup FIQ VICIntSelect |= 1 << 11; //Enable FIQ interrupts for SSP VICIntEnable = 1 << 11; // Enable SSP interrupt //UART0 interrupt setup //VICVectCntl3 = (1<<5) + 6; //Enable vectored interrupt slot 3 and set it to UART0 (interrupt source 6) // VICIntSelect &= ~(1<<6); //Clear bit 6 - use IRQ interrupts for UART0, not FIQ. //VICIntEnable = 1<<6; //Enable UART0 interrupt at vectored interrupt controller (VIC) }
static void do_start(struct cardstate *cs) { gigaset_free_channels(cs); if (cs->mstate != MS_LOCKED) schedule_init(cs, MS_INIT); cs->isdn_up = 1; gigaset_isdn_start(cs); cs->waiting = 0; wake_up(&cs->waitqueue); }
static int do_unlock(struct cardstate *cs) { if (cs->mstate != MS_LOCKED) return -EINVAL; cs->mstate = MS_UNINITIALIZED; cs->mode = M_UNKNOWN; gigaset_free_channels(cs); if (cs->connected) schedule_init(cs, MS_INIT); return 0; }
void openstack_init(OpenMote* self) { //===== drivers openserial_init(self); //===== stack //-- cross-layer idmanager_init(self); // call first since initializes EUI64 and isDAGroot openqueue_init(self); openrandom_init(self); opentimers_init(self); //-- 02a-TSCH adaptive_sync_init(self); ieee154e_init(self); //-- 02b-RES schedule_init(self); sixtop_init(self); neighbors_init(self); //-- 03a-IPHC openbridge_init(self); iphc_init(self); //-- 03b-IPv6 forwarding_init(self); icmpv6_init(self); icmpv6echo_init(self); icmpv6rpl_init(self); //-- 04-TRAN opentcp_init(self); openudp_init(self); opencoap_init(self); // initialize before any of the CoAP applications //===== applications openapps_init(self); openserial_printInfo(self, COMPONENT_OPENWSN,ERR_BOOTED, (errorparameter_t)0, (errorparameter_t)0 ); }
/* Entering cid mode or getting a cid failed: * try to initialize the device and try again. * * channel >= 0: getting cid for the channel failed * channel < 0: entering cid mode failed * * returns 0 on success, <0 on failure */ static int reinit_and_retry(struct cardstate *cs, int channel) { int i; if (--cs->retry_count <= 0) return -EFAULT; for (i = 0; i < cs->channels; ++i) if (cs->bcs[i].at_state.cid > 0) return -EBUSY; if (channel < 0) dev_warn(cs->dev, "Could not enter cid mode. Reinit device and try again.\n"); else { dev_warn(cs->dev, "Could not get a call id. Reinit device and try again.\n"); cs->bcs[channel].at_state.pending_commands |= PC_CID; } schedule_init(cs, MS_INIT); return 0; }
int main(void) { #ifdef CONFIG_INITCALL int ret; initcall_t *initcall; for (initcall = __rnk_initcalls_start; initcall < __rnk_initcalls_end; initcall++) { debug_printk("initcall-> %pS\n", *initcall); ret = (*initcall)(); if (ret < 0) error_printk("initcall %pS failed: %d\n", *initcall, ret); } #endif /* CONFIG_INITCALL */ printk("Welcome to rnk\r\n"); printk("- Initialise scheduler...\r\n"); #ifndef CONFIG_INITCALL schedule_init(); time_init(); #endif /* CONFIG_INITCALL */ #ifdef CONFIG_UNWIND unwind_init(); #endif /* CONFIG_UNWIND */ printk("- Add thread to scheduler\r\n"); add_thread(&loading_thread, 1); printk("- Start scheduling...\r\n"); start_schedule(); while(1) ; return 0; //Never reach }
static void process_command_flags(struct cardstate *cs) { struct at_state_t *at_state = NULL; struct bc_state *bcs; int i; int sequence; unsigned long flags; cs->commands_pending = 0; if (cs->cur_at_seq) { gig_dbg(DEBUG_EVENT, "not searching scheduled commands: busy"); return; } gig_dbg(DEBUG_EVENT, "searching scheduled commands"); sequence = SEQ_NONE; /* clear pending_commands and hangup channels on shutdown */ if (cs->at_state.pending_commands & PC_SHUTDOWN) { cs->at_state.pending_commands &= ~PC_CIDMODE; for (i = 0; i < cs->channels; ++i) { bcs = cs->bcs + i; at_state = &bcs->at_state; at_state->pending_commands &= ~(PC_DLE1 | PC_ACCEPT | PC_DIAL); if (at_state->cid > 0) at_state->pending_commands |= PC_HUP; if (at_state->pending_commands & PC_CID) { at_state->pending_commands |= PC_NOCID; at_state->pending_commands &= ~PC_CID; } } } /* clear pending_commands and hangup channels on reset */ if (cs->at_state.pending_commands & PC_INIT) { cs->at_state.pending_commands &= ~PC_CIDMODE; for (i = 0; i < cs->channels; ++i) { bcs = cs->bcs + i; at_state = &bcs->at_state; at_state->pending_commands &= ~(PC_DLE1 | PC_ACCEPT | PC_DIAL); if (at_state->cid > 0) at_state->pending_commands |= PC_HUP; if (cs->mstate == MS_RECOVER) { if (at_state->pending_commands & PC_CID) { at_state->pending_commands |= PC_NOCID; at_state->pending_commands &= ~PC_CID; } } } } /* only switch back to unimodem mode if no commands are pending and * no channels are up */ spin_lock_irqsave(&cs->lock, flags); if (cs->at_state.pending_commands == PC_UMMODE && !cs->cidmode && list_empty(&cs->temp_at_states) && cs->mode == M_CID) { sequence = SEQ_UMMODE; at_state = &cs->at_state; for (i = 0; i < cs->channels; ++i) { bcs = cs->bcs + i; if (bcs->at_state.pending_commands || bcs->at_state.cid > 0) { sequence = SEQ_NONE; break; } } } spin_unlock_irqrestore(&cs->lock, flags); cs->at_state.pending_commands &= ~PC_UMMODE; if (sequence != SEQ_NONE) { schedule_sequence(cs, at_state, sequence); return; } for (i = 0; i < cs->channels; ++i) { bcs = cs->bcs + i; if (bcs->at_state.pending_commands & PC_HUP) { if (cs->dle) { cs->curchannel = bcs->channel; schedule_sequence(cs, &cs->at_state, SEQ_DLE0); return; } bcs->at_state.pending_commands &= ~PC_HUP; if (bcs->at_state.pending_commands & PC_CID) { /* not yet dialing: PC_NOCID is sufficient */ bcs->at_state.pending_commands |= PC_NOCID; bcs->at_state.pending_commands &= ~PC_CID; } else { schedule_sequence(cs, &bcs->at_state, SEQ_HUP); return; } } if (bcs->at_state.pending_commands & PC_NOCID) { bcs->at_state.pending_commands &= ~PC_NOCID; cs->curchannel = bcs->channel; schedule_sequence(cs, &cs->at_state, SEQ_NOCID); return; } else if (bcs->at_state.pending_commands & PC_DLE0) { bcs->at_state.pending_commands &= ~PC_DLE0; cs->curchannel = bcs->channel; schedule_sequence(cs, &cs->at_state, SEQ_DLE0); return; } } list_for_each_entry(at_state, &cs->temp_at_states, list) if (at_state->pending_commands & PC_HUP) { at_state->pending_commands &= ~PC_HUP; schedule_sequence(cs, at_state, SEQ_HUP); return; } if (cs->at_state.pending_commands & PC_INIT) { cs->at_state.pending_commands &= ~PC_INIT; cs->dle = 0; cs->inbuf->inputstate = INS_command; schedule_sequence(cs, &cs->at_state, SEQ_INIT); return; } if (cs->at_state.pending_commands & PC_SHUTDOWN) { cs->at_state.pending_commands &= ~PC_SHUTDOWN; schedule_sequence(cs, &cs->at_state, SEQ_SHUTDOWN); return; } if (cs->at_state.pending_commands & PC_CIDMODE) { cs->at_state.pending_commands &= ~PC_CIDMODE; if (cs->mode == M_UNIMODEM) { cs->retry_count = 1; schedule_sequence(cs, &cs->at_state, SEQ_CIDMODE); return; } } for (i = 0; i < cs->channels; ++i) { bcs = cs->bcs + i; if (bcs->at_state.pending_commands & PC_DLE1) { bcs->at_state.pending_commands &= ~PC_DLE1; cs->curchannel = bcs->channel; schedule_sequence(cs, &cs->at_state, SEQ_DLE1); return; } if (bcs->at_state.pending_commands & PC_ACCEPT) { bcs->at_state.pending_commands &= ~PC_ACCEPT; schedule_sequence(cs, &bcs->at_state, SEQ_ACCEPT); return; } if (bcs->at_state.pending_commands & PC_DIAL) { bcs->at_state.pending_commands &= ~PC_DIAL; schedule_sequence(cs, &bcs->at_state, SEQ_DIAL); return; } if (bcs->at_state.pending_commands & PC_CID) { switch (cs->mode) { case M_UNIMODEM: cs->at_state.pending_commands |= PC_CIDMODE; gig_dbg(DEBUG_EVENT, "Scheduling PC_CIDMODE"); cs->commands_pending = 1; return; case M_UNKNOWN: schedule_init(cs, MS_INIT); return; } bcs->at_state.pending_commands &= ~PC_CID; cs->curchannel = bcs->channel; cs->retry_count = 2; schedule_sequence(cs, &cs->at_state, SEQ_CID); return; } } }
static void do_action(int action, struct cardstate *cs, struct bc_state *bcs, struct at_state_t **p_at_state, char **pp_command, int *p_genresp, int *p_resp_code, struct event_t *ev) { struct at_state_t *at_state = *p_at_state; struct bc_state *bcs2; unsigned long flags; int channel; unsigned char *s, *e; int i; unsigned long val; switch (action) { case ACT_NOTHING: break; case ACT_TIMEOUT: at_state->waiting = 1; break; case ACT_INIT: cs->at_state.pending_commands &= ~PC_INIT; cs->cur_at_seq = SEQ_NONE; cs->mode = M_UNIMODEM; spin_lock_irqsave(&cs->lock, flags); if (!cs->cidmode) { spin_unlock_irqrestore(&cs->lock, flags); gigaset_free_channels(cs); cs->mstate = MS_READY; break; } spin_unlock_irqrestore(&cs->lock, flags); cs->at_state.pending_commands |= PC_CIDMODE; gig_dbg(DEBUG_EVENT, "Scheduling PC_CIDMODE"); cs->commands_pending = 1; break; case ACT_FAILINIT: dev_warn(cs->dev, "Could not initialize the device.\n"); cs->dle = 0; init_failed(cs, M_UNKNOWN); cs->cur_at_seq = SEQ_NONE; break; case ACT_CONFIGMODE: init_failed(cs, M_CONFIG); cs->cur_at_seq = SEQ_NONE; break; case ACT_SETDLE1: cs->dle = 1; /* cs->inbuf[0].inputstate |= INS_command | INS_DLE_command; */ cs->inbuf[0].inputstate &= ~(INS_command | INS_DLE_command); break; case ACT_SETDLE0: cs->dle = 0; cs->inbuf[0].inputstate = (cs->inbuf[0].inputstate & ~INS_DLE_command) | INS_command; break; case ACT_CMODESET: if (cs->mstate == MS_INIT || cs->mstate == MS_RECOVER) { gigaset_free_channels(cs); cs->mstate = MS_READY; } cs->mode = M_CID; cs->cur_at_seq = SEQ_NONE; break; case ACT_UMODESET: cs->mode = M_UNIMODEM; cs->cur_at_seq = SEQ_NONE; break; case ACT_FAILCMODE: cs->cur_at_seq = SEQ_NONE; if (cs->mstate == MS_INIT || cs->mstate == MS_RECOVER) { init_failed(cs, M_UNKNOWN); break; } if (reinit_and_retry(cs, -1) < 0) schedule_init(cs, MS_RECOVER); break; case ACT_FAILUMODE: cs->cur_at_seq = SEQ_NONE; schedule_init(cs, MS_RECOVER); break; case ACT_HUPMODEM: /* send "+++" (hangup in unimodem mode) */ if (cs->connected) { struct cmdbuf_t *cb; cb = kmalloc(sizeof(struct cmdbuf_t) + 3, GFP_ATOMIC); if (!cb) { dev_err(cs->dev, "%s: out of memory\n", __func__); return; } memcpy(cb->buf, "+++", 3); cb->len = 3; cb->offset = 0; cb->next = NULL; cb->wake_tasklet = NULL; cs->ops->write_cmd(cs, cb); } break; case ACT_RING: /* get fresh AT state structure for new CID */ at_state = get_free_channel(cs, ev->parameter); if (!at_state) { dev_warn(cs->dev, "RING ignored: could not allocate channel structure\n"); break; } /* initialize AT state structure * note that bcs may be NULL if no B channel is free */ at_state->ConState = 700; for (i = 0; i < STR_NUM; ++i) { kfree(at_state->str_var[i]); at_state->str_var[i] = NULL; } at_state->int_var[VAR_ZCTP] = -1; spin_lock_irqsave(&cs->lock, flags); at_state->timer_expires = RING_TIMEOUT; at_state->timer_active = 1; spin_unlock_irqrestore(&cs->lock, flags); break; case ACT_ICALL: handle_icall(cs, bcs, at_state); break; case ACT_FAILSDOWN: dev_warn(cs->dev, "Could not shut down the device.\n"); /* fall through */ case ACT_FAKESDOWN: case ACT_SDOWN: cs->cur_at_seq = SEQ_NONE; finish_shutdown(cs); break; case ACT_CONNECT: if (cs->onechannel) { at_state->pending_commands |= PC_DLE1; cs->commands_pending = 1; break; } bcs->chstate |= CHS_D_UP; gigaset_isdn_connD(bcs); cs->ops->init_bchannel(bcs); break; case ACT_DLE1: cs->cur_at_seq = SEQ_NONE; bcs = cs->bcs + cs->curchannel; bcs->chstate |= CHS_D_UP; gigaset_isdn_connD(bcs); cs->ops->init_bchannel(bcs); break; case ACT_FAKEHUP: at_state->int_var[VAR_ZSAU] = ZSAU_NULL; /* fall through */ case ACT_DISCONNECT: cs->cur_at_seq = SEQ_NONE; at_state->cid = -1; if (!bcs) { disconnect_nobc(p_at_state, cs); } else if (cs->onechannel && cs->dle) { /* Check for other open channels not needed: * DLE only used for M10x with one B channel. */ at_state->pending_commands |= PC_DLE0; cs->commands_pending = 1; } else { disconnect_bc(at_state, cs, bcs); } break; case ACT_FAKEDLE0: at_state->int_var[VAR_ZDLE] = 0; cs->dle = 0; /* fall through */ case ACT_DLE0: cs->cur_at_seq = SEQ_NONE; bcs2 = cs->bcs + cs->curchannel; disconnect_bc(&bcs2->at_state, cs, bcs2); break; case ACT_ABORTHUP: cs->cur_at_seq = SEQ_NONE; dev_warn(cs->dev, "Could not hang up.\n"); at_state->cid = -1; if (!bcs) disconnect_nobc(p_at_state, cs); else if (cs->onechannel) at_state->pending_commands |= PC_DLE0; else disconnect_bc(at_state, cs, bcs); schedule_init(cs, MS_RECOVER); break; case ACT_FAILDLE0: cs->cur_at_seq = SEQ_NONE; dev_warn(cs->dev, "Error leaving DLE mode.\n"); cs->dle = 0; bcs2 = cs->bcs + cs->curchannel; disconnect_bc(&bcs2->at_state, cs, bcs2); schedule_init(cs, MS_RECOVER); break; case ACT_FAILDLE1: cs->cur_at_seq = SEQ_NONE; dev_warn(cs->dev, "Could not enter DLE mode. Trying to hang up.\n"); channel = cs->curchannel; cs->bcs[channel].at_state.pending_commands |= PC_HUP; cs->commands_pending = 1; break; case ACT_CID: /* got cid; start dialing */ cs->cur_at_seq = SEQ_NONE; channel = cs->curchannel; if (ev->parameter > 0 && ev->parameter <= 65535) { cs->bcs[channel].at_state.cid = ev->parameter; cs->bcs[channel].at_state.pending_commands |= PC_DIAL; cs->commands_pending = 1; break; } /* bad cid: fall through */ case ACT_FAILCID: cs->cur_at_seq = SEQ_NONE; channel = cs->curchannel; if (reinit_and_retry(cs, channel) < 0) { dev_warn(cs->dev, "Could not get a call ID. Cannot dial.\n"); bcs2 = cs->bcs + channel; disconnect_bc(&bcs2->at_state, cs, bcs2); } break; case ACT_ABORTCID: cs->cur_at_seq = SEQ_NONE; bcs2 = cs->bcs + cs->curchannel; disconnect_bc(&bcs2->at_state, cs, bcs2); break; case ACT_DIALING: case ACT_ACCEPTED: cs->cur_at_seq = SEQ_NONE; break; case ACT_ABORTACCEPT: /* hangup/error/timeout during ICALL procssng */ if (bcs) disconnect_bc(at_state, cs, bcs); else disconnect_nobc(p_at_state, cs); break; case ACT_ABORTDIAL: /* error/timeout during dial preparation */ cs->cur_at_seq = SEQ_NONE; at_state->pending_commands |= PC_HUP; cs->commands_pending = 1; break; case ACT_REMOTEREJECT: /* DISCONNECT_IND after dialling */ case ACT_CONNTIMEOUT: /* timeout waiting for ZSAU=ACTIVE */ case ACT_REMOTEHUP: /* DISCONNECT_IND with established connection */ at_state->pending_commands |= PC_HUP; cs->commands_pending = 1; break; case ACT_GETSTRING: /* warning: RING, ZDLE, ... are not handled properly anymore */ at_state->getstring = 1; break; case ACT_SETVER: if (!ev->ptr) { *p_genresp = 1; *p_resp_code = RSP_ERROR; break; } s = ev->ptr; if (!strcmp(s, "OK")) { /* OK without version string: assume old response */ *p_genresp = 1; *p_resp_code = RSP_NONE; break; } for (i = 0; i < 4; ++i) { val = simple_strtoul(s, (char **) &e, 10); if (val > INT_MAX || e == s) break; if (i == 3) { if (*e) break; } else if (*e != '.') break; else s = e + 1; cs->fwver[i] = val; } if (i != 4) { *p_genresp = 1; *p_resp_code = RSP_ERROR; break; } cs->gotfwver = 0; break; case ACT_GOTVER: if (cs->gotfwver == 0) { cs->gotfwver = 1; gig_dbg(DEBUG_EVENT, "firmware version %02d.%03d.%02d.%02d", cs->fwver[0], cs->fwver[1], cs->fwver[2], cs->fwver[3]); break; } /* fall through */ case ACT_FAILVER: cs->gotfwver = -1; dev_err(cs->dev, "could not read firmware version.\n"); break; case ACT_ERROR: gig_dbg(DEBUG_ANY, "%s: ERROR response in ConState %d", __func__, at_state->ConState); cs->cur_at_seq = SEQ_NONE; break; case ACT_DEBUG: gig_dbg(DEBUG_ANY, "%s: resp_code %d in ConState %d", __func__, ev->type, at_state->ConState); break; case ACT_WARN: dev_warn(cs->dev, "%s: resp_code %d in ConState %d!\n", __func__, ev->type, at_state->ConState); break; case ACT_ZCAU: dev_warn(cs->dev, "cause code %04x in connection state %d.\n", ev->parameter, at_state->ConState); break; /* events from the LL */ case ACT_DIAL: if (!ev->ptr) { *p_genresp = 1; *p_resp_code = RSP_ERROR; break; } start_dial(at_state, ev->ptr, ev->parameter); break; case ACT_ACCEPT: start_accept(at_state); break; case ACT_HUP: at_state->pending_commands |= PC_HUP; gig_dbg(DEBUG_EVENT, "Scheduling PC_HUP"); cs->commands_pending = 1; break; /* hotplug events */ case ACT_STOP: do_stop(cs); break; case ACT_START: do_start(cs); break; /* events from the interface */ case ACT_IF_LOCK: cs->cmd_result = ev->parameter ? do_lock(cs) : do_unlock(cs); cs->waiting = 0; wake_up(&cs->waitqueue); break; case ACT_IF_VER: if (ev->parameter != 0) cs->cmd_result = -EINVAL; else if (cs->gotfwver != 1) { cs->cmd_result = -ENOENT; } else { memcpy(ev->arg, cs->fwver, sizeof cs->fwver); cs->cmd_result = 0; } cs->waiting = 0; wake_up(&cs->waitqueue); break; /* events from the proc file system */ case ACT_PROC_CIDMODE: spin_lock_irqsave(&cs->lock, flags); if (ev->parameter != cs->cidmode) { cs->cidmode = ev->parameter; if (ev->parameter) { cs->at_state.pending_commands |= PC_CIDMODE; gig_dbg(DEBUG_EVENT, "Scheduling PC_CIDMODE"); } else { cs->at_state.pending_commands |= PC_UMMODE; gig_dbg(DEBUG_EVENT, "Scheduling PC_UMMODE"); } cs->commands_pending = 1; } spin_unlock_irqrestore(&cs->lock, flags); cs->waiting = 0; wake_up(&cs->waitqueue); break; /* events from the hardware drivers */ case ACT_NOTIFY_BC_DOWN: bchannel_down(bcs); break; case ACT_NOTIFY_BC_UP: bchannel_up(bcs); break; case ACT_SHUTDOWN: do_shutdown(cs); break; default: if (action >= ACT_CMD && action < ACT_CMD + AT_NUM) { *pp_command = at_state->bcs->commands[action - ACT_CMD]; if (!*pp_command) { *p_genresp = 1; *p_resp_code = RSP_NULL; } } else dev_err(cs->dev, "%s: action==%d!\n", __func__, action); } }
int main(int argc, char *argv[]) { struct configuration config; int i; const char *catalog_path; struct result_queue *queue; struct queryrunner *runner; struct keygrab_data keygrab_data; for(i=1; i<argc; i++) { const char *arg = argv[i]; if(strcmp("--kill", arg)==0) { return ocha_init_kill() ? 0:99; } } ocha_init("ochad", argc, argv, TRUE/*has gui*/, &config); if(ocha_init_ocha_is_running()) { already_running(); return 89; } if(!ocha_init_create_socket()) { return 71; } restart_register(argv[0]); ocha_init_requires_catalog(config.catalog_path); chdir(g_get_home_dir()); for(i=1; i<argc; i++) { const char *arg = argv[i]; if(strncmp("--pid=", arg, strlen("--pid="))==0) { const char *file=&arg[strlen("--pid=")]; pid_t pid = getpid(); FILE* pidh = fopen(file, "w"); if(pidh==NULL) { fprintf(stderr, "error: cannot open pid file %s\n", file); exit(14); } fprintf(pidh, "%d\n", pid); fclose(pidh); } } schedule_init(&config); querywin_init(); catalog_path = config.catalog_path; queue = querywin_get_result_queue(); runner=catalog_queryrunner_new(catalog_path, queue); querywin_set_queryrunner(runner); configure_keygrab(&keygrab_data); gtk_main(); return 0; }
void eventloop(tsocket main_fd, tsocket main_sctp_fd) { static uint32 child_count = 0; static int conn_count = 0; static RTSP_buffer *rtsp_list = NULL; tsocket max_fd, fd = -1; RTSP_buffer *p = NULL; RTSP_proto rtsp_proto; uint32 fd_found; fd_set rset,wset; //Init of scheduler FD_ZERO(&rset); FD_ZERO(&wset); if (conn_count != -1) { /* This is the process allowed for accepting new clients */ FD_SET(main_fd, &rset); max_fd = main_fd; } /* Add all sockets of all sessions to fd_sets */ for (p = rtsp_list; p; p = p->next) { rtsp_set_fdsets(p, &max_fd, &rset, &wset, NULL); } /* Stay here and wait for something happens */ if (select(max_fd+1, &rset, &wset, NULL, NULL) < 0) { ERRORLOGG("select error in eventloop()"); /* Maybe we have to force exit here*/ return; } /* transfer data for any RTSP sessions */ schedule_connections(&rtsp_list, &conn_count, &rset, &wset, NULL); /* handle new connections */ if (conn_count != -1) { if (FD_ISSET(main_fd, &rset)) { fd = tcp_accept(main_fd); rtsp_proto = TCP; } // Handle a new connection if (fd >= 0) { for (fd_found = 0, p = rtsp_list; p != NULL; p = p->next) { if (p->fd == fd) { fd_found = 1; break; } } if (!fd_found) { if (conn_count < ONE_FORK_MAX_CONNECTION) { ++conn_count; // ADD A CLIENT add_client(&rtsp_list, fd, rtsp_proto); } else { if (fork() == 0) { // I'm the child ++child_count; RTP_port_pool_init (ONE_FORK_MAX_CONNECTION * child_count * 2 + RTP_DEFAULT_PORT); if (schedule_init() == ERR_FATAL) { FATALLOGG("Can't start schedule. Server is aborting"); return; } conn_count = 1; rtsp_list = NULL; add_client(&rtsp_list, fd, rtsp_proto); } else { // I'm the father fd = -1; conn_count = -1; tcp_close(main_fd); } } num_conn++; INFOLOGG("Connection reached: %d", num_conn); } } } // shawill: and... if not? END OF "HANDLE NEW CONNECTIONS" }
int main(void) { char s[] = "1442936700,0,1,4,#2346W,3,#0800O#1900C#0900O#1800C"; // for str_processing test RCC_ClocksTypeDef RCC_Clocks; /* SysTick end of count event each 10ms */ RCC_GetClocksFreq(&RCC_Clocks); SysTick_Config(RCC_Clocks.HCLK_Frequency / 100); RCC_AHB2PeriphClockCmd(RCC_AHB2Periph_RNG, ENABLE); RNG_Cmd(ENABLE); /* Initialize the timer for dht11 */ tim_init(TIM2); /* Initialize the SRAM ****************************************************/ PSRAM_Init(); /* Initialize the LCD *****************************************************/ LCD_Init(); LCD_LOG_Init(); LCD_LOG_SetHeader((uint8_t*)" Ethernet test"); LCD_LOG_SetFooter ((uint8_t*)" localtime: "); /* Add your application code here */ /* Configure ethernet (GPIOs, clocks, MAC, DMA) */ ETH_BSP_Config(); /* Initilaize the LwIP stack */ LwIP_Init(); schedule_init(&schedule_got,schedule_string); // schedule string store in schedule_string DNS_Init(); //while(!schedule_got); // wait until string got LCD_DisplayStringLine(Line2, (uint8_t*)schedule_string); LCD_DisplayStringLine(Line3, (uint8_t*)"0"); /* Main Loop */ //process ste str form internet Str_Split(s, Init_time); // s is temp string RTC_Config(); Time_Date_Setting(Init_time->year, Init_time->mon, Init_time->day, Init_time->hour +3, Init_time->min, Init_time->sec); while (1) { uint8_t year, mon, day; uint8_t hour, min, sec; RTC_TimeTypeDef RTC_TimeStruct_main; RTC_DateTypeDef RTC_DateStruct_main; RTC_GetDate(RTC_Format_BIN, &RTC_DateStruct_main); RTC_GetTime(RTC_Format_BIN, &RTC_TimeStruct_main); year = RTC_DateStruct_main.RTC_Year; mon = RTC_DateStruct_main.RTC_Month; day = RTC_DateStruct_main.RTC_Date; hour = RTC_TimeStruct_main.RTC_Hours; min = RTC_TimeStruct_main.RTC_Minutes; sec = RTC_TimeStruct_main.RTC_Seconds; //detect whether it is time to turn on Motor and LED, then execute it. Soak(day, hour, min ); Water(day, hour, min, sec); Light(mon, day, hour, min); //detect over /* check if any packet received */ if (ETH_CheckFrameReceived()) { /* process received ethernet packet */ LwIP_Pkt_Handle(); } /* handle periodic timers for LwIP */ LwIP_Periodic_Handle(LocalTime); } }