int usb_cdc_status_set(usb_cdc_class_t * cl, struct serial_status * stat) { struct usb_cdc_acm_dev * dev = (struct usb_cdc_acm_dev *)cl; struct cdc_notification * pkt; uint32_t buf[4]; uint32_t status; status = stat->dsr ? CDC_SERIAL_STATE_TX_CARRIER : 0; status |= stat->ri ? CDC_SERIAL_STATE_RING : 0; status |= stat->dcd ? CDC_SERIAL_STATE_RX_CARRIER : 0; status |= stat->cts ? 0 : 0; status |= stat->brk ? CDC_SERIAL_STATE_BREAK : 0; if (dev->acm.status != status) { int ret; DCC_LOG(LOG_INFO, "status update"); pkt = (struct cdc_notification *)buf; /* bmRequestType */ pkt->bmRequestType = USB_CDC_NOTIFICATION; /* bNotification */ pkt->bNotification = CDC_NOTIFICATION_SERIAL_STATE; /* wValue */ pkt->wValue = 0; /* wIndex */ pkt->wIndex = 1; /* wLength */ pkt->wLength = 2; /* data */ pkt->bData[0] = status; pkt->bData[1] = 0; thinkos_flag_clr(CTL_FLAG); ret = usb_dev_ep_tx_start(dev->usb, dev->int_ep, pkt, sizeof(struct cdc_notification)); if (ret < 0) { DCC_LOG(LOG_WARNING, "usb_dev_ep_tx_start() failed!"); return ret; } DCC_LOG1(LOG_INFO, "ret=%d wait", ret); thinkos_flag_wait(CTL_FLAG); thinkos_flag_clr(CTL_FLAG); DCC_LOG(LOG_INFO, "CTL wakeup..."); /* FIXME: handle failures .... */ /* set the status */ dev->acm.status = status; } return 0; }
int led_task(void) { DCC_LOG1(LOG_TRACE, "[%d] started.", thinkos_thread_self()); while (1) { DCC_LOG(LOG_MSG, "thinkos_flag_wait()..."); thinkos_flag_wait(led_flag); if (led1_flash_tail != led1_flash_head) { led1_flash_tail++; if (!led_locked) led1_on(); } if (led2_flash_tail != led2_flash_head) { led2_flash_tail++; if (!led_locked) led2_on(); } if ((led1_flash_tail == led1_flash_head) && (led2_flash_tail == led2_flash_head)) thinkos_flag_clr(led_flag); thinkos_sleep(100); if (!led_locked) { led1_off(); led2_off(); } thinkos_sleep(100); } }
int usb_cdc_ctl_wait(usb_cdc_class_t * cl, unsigned int msec) { struct usb_cdc_acm_dev * dev = (struct usb_cdc_acm_dev *)cl; (void)dev; thinkos_flag_wait(CTL_FLAG); thinkos_flag_clr(CTL_FLAG); DCC_LOG(LOG_INFO, "CTL wakeup..."); return 0; }
int net_probe(void) { void * pkt; int ret; /* drain the transmmit queue */ pkt = rs485_pkt_drain(&net.link); if (pkt != NULL) pktbuf_free(pkt); /* set the probe pin low */ net.probe_mode = true; stm32_gpio_clr(RS485_MODE); DCC_LOG(LOG_TRACE, "Probe mode."); thinkos_flag_clr(net.probe_flag); if ((pkt = pktbuf_alloc()) != NULL) { uint32_t seq; while ((seq = rand()) == 0); /* send a probe packet */ sprintf((char *)pkt, "PRB=%08x", seq); DCC_LOG1(LOG_TRACE, "seq=0x%08x", seq); rs485_pkt_enqueue(&net.link, pkt, 12); net.stat.tx.pkt_cnt++; net.stat.tx.octet_cnt += 12; /* wait for the end of transmission */ pkt = rs485_pkt_drain(&net.link); pktbuf_free(pkt); if ((ret = thinkos_flag_timedwait(net.probe_flag, 10)) == 0) { if (seq != net.probe_seq) { DCC_LOG(LOG_WARNING, "probe sequence mismatch!"); ret = -1; } } else if (ret == THINKOS_ETIMEDOUT) { DCC_LOG(LOG_WARNING, "probe sequence timedout!"); } DCC_LOG1(LOG_TRACE, "seq=0x%08x", seq); } else { DCC_LOG(LOG_ERROR, "pktbuf_alloc() failed!"); ret = -1; } /* set the probe pin high */ net.probe_mode = false; stm32_gpio_set(RS485_MODE); DCC_LOG(LOG_TRACE, "Probe mode."); return ret; }
usb_cdc_class_t * usb_cdc_init(const usb_dev_t * usb, const uint8_t * const str[], unsigned int strcnt) { struct usb_cdc_acm_dev * dev = &usb_cdc_rt; usb_class_t * cl = (usb_class_t *)dev; /* initialize USB device */ dev->usb = (usb_dev_t *)usb; #ifndef CDC_RX_SEM_NO dev->rx_sem = thinkos_sem_alloc(0); #endif #ifndef CDC_TX_DONE_NO dev->tx_done = thinkos_flag_alloc(); #endif #ifndef CDC_TX_LOCK_NO dev->tx_lock = thinkos_flag_alloc(); #endif #ifndef CDC_CTL_FLAG_NO dev->ctl_flag = thinkos_flag_alloc(); #endif dev->rx_cnt = 0; dev->rx_pos = 0; dev->str = str; dev->strcnt = strcnt; DCC_LOG4(LOG_INFO, "tx_done=%d tx_lock=%d rx_sem=%d ctl_flag=%d", TX_DONE, TX_LOCK, RX_SEM, CTL_FLAG); thinkos_flag_clr(TX_DONE); thinkos_flag_clr(TX_LOCK); thinkos_flag_clr(CTL_FLAG); usb_dev_init(dev->usb, cl, &usb_cdc_ev); return (usb_cdc_class_t *)dev; }
int usb_cdc_acm_lc_wait(usb_cdc_class_t * cl) { struct usb_cdc_acm_dev * dev = (struct usb_cdc_acm_dev *)cl; while ((dev->acm.flags & ACM_LC_SET) == 0) { DCC_LOG(LOG_INFO, "CTL wait"); thinkos_flag_wait(CTL_FLAG); thinkos_flag_clr(CTL_FLAG); DCC_LOG(LOG_INFO, "CTL wakeup..."); } return 0; }
int usb_cdc_dte_wait(usb_cdc_class_t * cl) { struct usb_cdc_acm_dev * dev = (struct usb_cdc_acm_dev *)cl; while ((dev->acm.control & CDC_DTE_PRESENT) == 0) { DCC_LOG(LOG_INFO, "wait"); thinkos_flag_wait(CTL_FLAG); thinkos_flag_clr(CTL_FLAG); DCC_LOG(LOG_INFO, "CTL wakeup..."); } return 0; }
void supv_sync(void) { thinkos_flag_clr(adc_dma_sync); thinkos_flag_wait(adc_dma_sync); }
static int rsp_last_signal(struct gdb_rspd * gdb, struct tcp_pcb * tp, char * pkt, int len) { int state; state = target_status(); if (state < DBG_ST_CONNECTED) { DCC_LOG(LOG_WARNING, "target not connected!"); return rsp_error(tp, state); } if (state != DBG_ST_HALTED) { DCC_LOG(LOG_TRACE, "running"); if ((state = target_halt(0)) < 0) { DCC_LOG(LOG_WARNING, "target_halt() failed!"); rsp_msg(tp, pkt, "YARD-ICE: halt fail\n"); return rsp_error(tp, 1); } if ((state = target_halt_wait(500)) == ERR_TIMEOUT) { DCC_LOG(LOG_TRACE, "timeout..."); rsp_msg(tp, pkt, "YARD-ICE: target_halt failed!"); return rsp_error(tp, 1); } } if (state == DBG_ST_HALTED) { DCC_LOG(LOG_TRACE, "halted"); thinkos_flag_clr(gdb->run_flag); return rsp_signal(tp, pkt, SIGTRAP); } switch (state) { case DBG_ST_ERROR: rsp_msg(tp, pkt, "YARD-ICE: error state\n"); break; case DBG_ST_OUTOFSYNC: DCC_LOG(LOG_TRACE, "out of sync"); rsp_msg(tp, pkt, "YARD-ICE: Out of sync\n"); break; case DBG_ST_BUSY: DCC_LOG(LOG_TRACE, "busy..."); rsp_msg(tp, pkt, "YARD-ICE: busy ... \n"); break; case DBG_ST_UNDEF: rsp_msg(tp, pkt, "YARD-ICE: undefined state\n"); break; case DBG_ST_UNCONNECTED: DCC_LOG(LOG_TRACE, "unconnected"); rsp_msg(tp, pkt, "YARD-ICE: unconnected ?\n"); break; case DBG_ST_CONNECTED: DCC_LOG(LOG_TRACE, "connected"); rsp_msg(tp, pkt, "YARD-ICE: connected (busy)\n"); break; case DBG_ST_RUNNING: DCC_LOG(LOG_TRACE, "running"); rsp_msg(tp, pkt, "YARD-ICE: running\n"); thinkos_flag_set(gdb->run_flag); break; default: DCC_LOG1(LOG_WARNING, "unknown state: %d", state); rsp_msg(tp, pkt, "YARD-ICE: unknown state, bailing out!\n"); return -1; } return rsp_error(tp, 1); }