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);
}
