static vsf_err_t hub_init_thread(struct vsfsm_pt_t *pt, vsfsm_evt_t evt) { vsf_err_t err; struct vsfusbh_hub_t *hub = (struct vsfusbh_hub_t *)pt->user_data; struct vsfusbh_urb_t *vsfurb = hub->vsfurb; vsfsm_pt_begin(pt); vsfurb->sm = &hub->sm; // init hub err = hub_class_check(hub); if (err != VSFERR_NONE) return err; vsfurb->transfer_buffer = &hub->hub_desc; vsfurb->transfer_length = 4; err = hub_get_descriptor(hub->usbh, vsfurb); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; if (hub->hub_desc.bDescLength > sizeof(hub->hub_desc)) { return VSFERR_FAIL; } vsfurb->transfer_buffer = &hub->hub_desc; vsfurb->transfer_length = hub->hub_desc.bDescLength; err = hub_get_descriptor(hub->usbh, vsfurb); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; hub->dev->maxchild = min(hub->hub_desc.bNbrPorts, USB_MAXCHILDREN); vsfurb->transfer_buffer = &hub->hub_status; vsfurb->transfer_length = sizeof(hub->hub_status); err = hub_get_status(hub->usbh, vsfurb); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; hub->counter = 0; do { hub->counter++; hub->vsfurb->transfer_buffer = NULL; hub->vsfurb->transfer_length = 0; err = hub_set_port_feature(hub->usbh, hub->vsfurb, hub->counter, USB_PORT_FEAT_POWER); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; vsfsm_pt_delay(pt, hub->hub_desc.bPwrOn2PwrGood * 2); } while (hub->counter < hub->dev->maxchild); vsfsm_pt_end(pt); return VSFERR_NONE; }
static vsf_err_t hub_reset_thread(struct vsfsm_pt_t *pt, vsfsm_evt_t evt) { struct vsfusbh_hub_t *hub = (struct vsfusbh_hub_t *)pt->user_data; struct vsfusbh_urb_t *vsfurb = hub->vsfurb; vsf_err_t err; vsfsm_pt_begin(pt); hub->retry = 0; do { /* send command to reset port */ vsfurb->transfer_buffer = NULL; vsfurb->transfer_length = 0; err = hub_set_port_feature(hub->usbh, vsfurb, hub->counter, USB_PORT_FEAT_RESET); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; /* delay 100ms after port reset*/ vsfsm_pt_delay(pt, 100); // clear reset vsfurb->transfer_buffer = NULL; vsfurb->transfer_length = 0; err = hub_clear_port_feature(hub->usbh, vsfurb, hub->counter, USB_PORT_FEAT_C_RESET); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; /* delay 100ms after port reset*/ vsfsm_pt_delay(pt, 50); /* get port status for check */ vsfurb->transfer_buffer = &hub->hub_portsts; vsfurb->transfer_length = sizeof(hub->hub_portsts); err = hub_get_port_status(hub->usbh, vsfurb, hub->counter); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; /* check port status after reset */ if (hub->hub_portsts.wPortStatus & USB_PORT_STAT_ENABLE) { return VSFERR_NONE; } else { /* delay 200ms for next reset*/ vsfsm_pt_delay(pt, 200); } } while (hub->retry++ <= 3); vsfsm_pt_end(pt); return VSFERR_FAIL; }
static vsf_err_t hub_scan_thread(struct vsfsm_pt_t *pt, vsfsm_evt_t evt) { vsf_err_t err; struct vsfusbh_hub_t *hub = (struct vsfusbh_hub_t *)pt->user_data; struct vsfusbh_urb_t *vsfurb = hub->vsfurb; vsfsm_pt_begin(pt); do { hub->counter = 1; do { // get port status vsfurb->transfer_buffer = &hub->hub_portsts; vsfurb->transfer_length = sizeof(hub->hub_portsts); err = hub_get_port_status(hub->usbh, vsfurb, hub->counter); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; if (hub->hub_portsts.wPortChange & USB_PORT_STAT_C_CONNECTION) { // try to connect vsfsm_pt_wfpt(pt, &hub->drv_connect_pt); } else if (hub->hub_portsts.wPortChange & USB_PORT_STAT_C_ENABLE) { vsfurb->transfer_buffer = NULL; vsfurb->transfer_length = 0; err = hub_clear_port_feature(hub->usbh, vsfurb, hub->counter, USB_PORT_FEAT_C_ENABLE); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; hub->hub_portsts.wPortChange &= ~USB_PORT_STAT_C_ENABLE; } if (hub->hub_portsts.wPortChange & USB_PORT_STAT_C_SUSPEND) { vsfurb->transfer_buffer = NULL; vsfurb->transfer_length = 0; err = hub_clear_port_feature(hub->usbh, vsfurb, hub->counter, USB_PORT_FEAT_C_SUSPEND); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; hub->hub_portsts.wPortChange &= ~USB_PORT_STAT_C_SUSPEND; } if (hub->hub_portsts.wPortChange & USB_PORT_STAT_C_OVERCURRENT) { vsfurb->transfer_buffer = NULL; vsfurb->transfer_length = 0; err = hub_clear_port_feature(hub->usbh, vsfurb, hub->counter, USB_PORT_FEAT_C_OVER_CURRENT); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; hub->hub_portsts.wPortChange &= ~USB_PORT_FEAT_C_OVER_CURRENT; // TODO : power every port } if (hub->hub_portsts.wPortChange & USB_PORT_STAT_C_RESET) { vsfurb->transfer_buffer = NULL; vsfurb->transfer_length = 0; err = hub_clear_port_feature(hub->usbh, vsfurb, hub->counter, USB_PORT_FEAT_C_RESET); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; hub->hub_portsts.wPortChange &= ~USB_PORT_FEAT_C_RESET; } } while (hub->counter++ < hub->dev->maxchild); // TODO : poll hub status vsfsm_pt_delay(pt, 500); } while (1); vsfsm_pt_end(pt); return VSFERR_NONE; }
static vsf_err_t hub_connect_thread(struct vsfsm_pt_t *pt, vsfsm_evt_t evt) { vsf_err_t err; struct vsfusbh_hub_t *hub = (struct vsfusbh_hub_t *)pt->user_data; struct vsfusbh_urb_t *vsfurb = hub->vsfurb; struct vsfusbh_device_t *dev; vsfsm_pt_begin(pt); /* clear the cnnection change state */ vsfurb->transfer_buffer = NULL; vsfurb->transfer_length = 0; err = hub_clear_port_feature(hub->usbh, vsfurb, hub->counter, USB_PORT_FEAT_C_CONNECTION); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; if (hub->dev->children[hub->counter - 1] != NULL) { vsfusbh_disconnect_device(hub->usbh, &hub->dev->children[hub->counter - 1]); } if (!(hub->hub_portsts.wPortStatus & USB_PORT_STAT_CONNECTION)) { if (hub->hub_portsts.wPortStatus & USB_PORT_STAT_ENABLE) { vsfurb->transfer_buffer = NULL; vsfurb->transfer_length = 0; err = hub_clear_port_feature(hub->usbh, vsfurb, hub->counter, USB_PORT_FEAT_ENABLE); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (vsfurb->status != URB_OK) return VSFERR_FAIL; } return VSFERR_NONE; } if (hub->hub_portsts.wPortStatus & USB_PORT_STAT_LOW_SPEED) { vsfsm_pt_delay(pt, 200); } vsfsm_pt_wfpt(pt, &hub->drv_reset_pt); vsfsm_pt_delay(pt, 200); // wait for new_dev free while (hub->usbh->new_dev != NULL) { vsfsm_pt_delay(pt, 200); } dev = vsfusbh_alloc_device(hub->usbh); if (NULL == dev) return VSFERR_FAIL; if (hub->hub_portsts.wPortStatus & USB_PORT_STAT_LOW_SPEED) { dev->speed = USB_SPEED_LOW; dev->slow = 1; } else if (hub->hub_portsts.wPortStatus & USB_PORT_STAT_HIGH_SPEED) dev->speed = USB_SPEED_HIGH; else dev->speed = USB_SPEED_FULL; hub->dev->children[hub->counter - 1] = dev; dev->parent = hub->dev; hub->usbh->new_dev = dev; vsfsm_post_evt_pending(&hub->usbh->sm, VSFSM_EVT_NEW_DEVICE); vsfsm_pt_end(pt); return VSFERR_NONE; }
vsf_err_t vsfusbh_probe_thread(struct vsfsm_pt_t *pt, vsfsm_evt_t evt) { vsf_err_t err; uint32_t len; struct vsfusbh_t *usbh = (struct vsfusbh_t *)pt->user_data; struct vsfusbh_urb_t *probe_urb = usbh->probe_urb; struct vsfusbh_device_t *dev = usbh->new_dev; vsfsm_pt_begin(pt); dev->devnum_temp = dev->devnum; dev->devnum = 0; dev->epmaxpacketin[0] = 8; dev->epmaxpacketout[0] = 8; probe_urb->vsfdev = dev; probe_urb->sm = &usbh->sm; probe_urb->timeout = DEFAULT_TIMEOUT; // get 8 bytes device descriptor probe_urb->transfer_buffer = &dev->descriptor; probe_urb->transfer_length = 8; err = vsfusbh_get_descriptor(usbh, probe_urb, USB_DT_DEVICE, 0); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (probe_urb->status != URB_OK) return VSFERR_FAIL; dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0; dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0; // set address dev->devnum = dev->devnum_temp; probe_urb->transfer_buffer = NULL; probe_urb->transfer_length = 0; err = vsfusbh_set_address(usbh, probe_urb); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (probe_urb->status != URB_OK) return VSFERR_FAIL; vsfsm_pt_delay(pt, 10); // get full device descriptor probe_urb->transfer_buffer = &dev->descriptor; probe_urb->transfer_length = sizeof(dev->descriptor); err = vsfusbh_get_descriptor(usbh, probe_urb, USB_DT_DEVICE, 0); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (probe_urb->status != URB_OK) return VSFERR_FAIL; // NOTE: only probe first configuration if (dev->descriptor.bNumConfigurations < 1) return VSFERR_FAIL; dev->num_config = 1; // NOTE: not min(USB_MAXCONFIG, dev->descriptor.bNumConfigurations) len = sizeof(struct usb_config_t) * dev->num_config; dev->config = vsf_bufmgr_malloc_aligned(len, 4); if (dev->config == NULL) { vsf_bufmgr_free(probe_urb->transfer_buffer); return VSFERR_FAIL; } memset(dev->config, 0, sizeof(struct usb_config_t) * dev->num_config); for (dev->temp_u8 = 0; dev->temp_u8 < dev->num_config; dev->temp_u8++) { // get 9 bytes configuration probe_urb->transfer_buffer = vsf_bufmgr_malloc(9); if (probe_urb->transfer_buffer == NULL) goto get_config_fail; probe_urb->transfer_length = 9; err = vsfusbh_get_descriptor(usbh, probe_urb, USB_DT_CONFIG, dev->temp_u8); if (err != VSFERR_NONE) goto get_config_fail; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (probe_urb->status != URB_OK) goto get_config_fail; // get wTotalLength len = GET_U16_LSBFIRST(&((uint8_t *)(probe_urb->transfer_buffer))[2]); vsf_bufmgr_free(probe_urb->transfer_buffer); // get full configuation probe_urb->transfer_buffer = vsf_bufmgr_malloc(len); if (probe_urb->transfer_buffer == NULL) goto get_config_fail; probe_urb->transfer_length = len; err = vsfusbh_get_descriptor(usbh, probe_urb, USB_DT_CONFIG, dev->temp_u8); if (err != VSFERR_NONE) goto get_config_fail; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (probe_urb->status != URB_OK) goto get_config_fail; // check wTotalLength len = GET_U16_LSBFIRST(&((uint8_t *)(probe_urb->transfer_buffer))[2]); if (probe_urb->actual_length != len) goto get_config_fail; err = parse_configuration(dev->config + dev->temp_u8, probe_urb->transfer_buffer); if (err != VSFERR_NONE) goto get_config_fail; dev->config[dev->temp_u8].config_buffer = probe_urb->transfer_buffer; probe_urb->transfer_buffer = NULL; continue; get_config_fail: if (probe_urb->transfer_buffer != NULL) { vsf_bufmgr_free(probe_urb->transfer_buffer); probe_urb->transfer_buffer = NULL; } // NOTE: do not free dev->config here !!! return VSFERR_FAIL; } // set the default configuration probe_urb->transfer_buffer = NULL; probe_urb->transfer_length = 0; err = vsfusbh_set_configuration(usbh, probe_urb, dev->config->bConfigurationValue); if (err != VSFERR_NONE) return err; vsfsm_pt_wfe(pt, VSFSM_EVT_URB_COMPLETE); if (probe_urb->status != URB_OK) return VSFERR_FAIL; dev->actconfig = dev->config; vsfusbh_set_maxpacket_ep(dev); vsfsm_pt_end(pt); return VSFERR_NONE; }
static vsf_err_t vsfip_telnetd_session_tx_thread(struct vsfsm_pt_t *pt, vsfsm_evt_t evt) { struct vsfip_telnetd_session_t *session = (struct vsfip_telnetd_session_t *)pt->user_data; uint32_t len; vsf_err_t err; vsfsm_pt_begin(pt); session->caller_txpt.sm = pt->sm; while (!session->disconnect) { len = stream_get_data_size(session->stream_tx); if (!len && vsfsm_sem_pend(&session->stream_tx_sem, pt->sm)) { vsfsm_pt_wfe(pt, VSFIP_TELNETD_EVT_STREAM_IN); if (session->disconnect) break; continue; } retry_alloc_buf: session->outbuf = VSFIP_TCPBUF_GET(len); if (NULL == session->outbuf) { vsfsm_pt_delay(pt, 5); if (session->disconnect) break; goto retry_alloc_buf; } session->outbuf->app.size = stream_read(session->stream_tx, &session->outbuf->app); if (!session->outbuf->app.size) { vsfip_buffer_release(session->outbuf); continue; } session->caller_txpt.state = 0; vsfsm_pt_entry(pt); err = vsfip_tcp_send(&session->caller_txpt, evt, session->so, &session->so->remote_sockaddr, session->outbuf, false); if (err > 0) return err; else if (err < 0) { session->disconnect = true; } } // close tcp socket session->caller_txpt.state = 0; vsfsm_pt_entry(pt); err = vsfip_tcp_close(&session->caller_txpt, evt, session->so); if (err > 0) return err; // close socket no matter if tcp closed OK or not vsfip_close(session->so); session->connected = false; vsfsm_pt_end(pt); return VSFERR_NONE; }
// vsfos static vsf_err_t vsfos_thread(struct vsfsm_pt_t *pt, vsfsm_evt_t evt) { struct vsfos_modifs_t *ifs = (struct vsfos_modifs_t *)pt->user_data; vsf_err_t err; vsfsm_pt_begin(pt); vsfhal_core_init(NULL); vsfhal_tickclk_init(); vsfhal_tickclk_start(); // timer VSFPOOL_INIT(&ifs->vsftimer_pool, struct vsftimer_t, VSFOSCFG_VSFSM_PENDSVQ_LEN); vsftimer_init(&ifs->vsftimer_memop); vsfhal_tickclk_config_cb(vsfos_tickclk_callback_int, NULL); // file VSFPOOL_INIT(&ifs->vfsfile_pool, struct vsfile_vfsfile_t, VSFOSCFG_VFS_NO); vsfile_init(&ifs->fs.memop); ifs->caller_pt.state = 0; vsfsm_pt_entry(pt); err = vsfile_addfile(&ifs->caller_pt, evt, NULL, "msc_root", VSFILE_ATTR_DIRECTORY); if (err != 0) return err; ifs->caller_pt.state = 0; vsfsm_pt_entry(pt); err = vsfile_getfile(&ifs->caller_pt, evt, NULL, "/msc_root", &ifs->file); if (err != 0) return err; ifs->caller_pt.state = 0; ifs->caller_pt.user_data = &ifs->mal.fakefat32; err = vsfile_mount(&ifs->caller_pt, evt, (struct vsfile_fsop_t *)&fakefat32_fs_op, ifs->file); if (err != 0) return err; // vsfip { struct vsfip_buffer_t *buffer; int i; buffer = &ifs->tcpip.buffer_pool.buffer[0]; for (i = 0; i < VSFOSCFG_VSFIP_BUFFER_NUM; i++) { buffer->buffer = ifs->tcpip.buffer_mem[i]; buffer++; } } VSFPOOL_INIT(&ifs->tcpip.buffer_pool, struct vsfip_buffer_t, VSFOSCFG_VSFIP_BUFFER_NUM); VSFPOOL_INIT(&ifs->tcpip.socket_pool, struct vsfip_socket_t, VSFOSCFG_VSFIP_SOCKET_NUM); VSFPOOL_INIT(&ifs->tcpip.tcppcb_pool, struct vsfip_tcppcb_t, VSFOSCFG_VSFIP_TCPPCB_NUM); vsfip_init((struct vsfip_mem_op_t *)&ifs->tcpip.mem_op); STREAM_INIT(&ifs->usbd.cdc.stream_rx); STREAM_INIT(&ifs->usbd.cdc.stream_tx); vsfscsi_init(&ifs->mal.scsi_dev); vsfusbd_device_init(&ifs->usbd.device); vsfshell_init(&ifs->shell); vsfos_busybox_init(&ifs->shell); if ((ifs->hwcfg->usbd.pullup.port != IFS_DUMMY_PORT) && (vsfhal_gpio_if != NULL)) { uint8_t port = ifs->hwcfg->usbd.pullup.port; uint8_t pin = ifs->hwcfg->usbd.pullup.pin; vsfhal_gpio_init(port); vsfhal_gpio_clear(port, 1 << pin); vsfhal_gpio_config_pin(port, pin, GPIO_OUTPP); } ifs->usbd.device.drv->disconnect(); vsfsm_pt_delay(pt, 200); if ((ifs->hwcfg->usbd.pullup.port != IFS_DUMMY_PORT) && (vsfhal_gpio_if != NULL)) { uint8_t port = ifs->hwcfg->usbd.pullup.port; uint8_t pin = ifs->hwcfg->usbd.pullup.pin; vsfhal_gpio_set(port, 1 << pin); } ifs->usbd.device.drv->connect(); while (1) { vsfsm_pt_delay(pt, 1000); asm("nop"); vsfsm_pt_delay(pt, 1000); asm("nop"); vsfsm_pt_delay(pt, 1000); asm("nop"); vsfsm_pt_delay(pt, 1000); asm("nop"); vsfsm_pt_delay(pt, 1000); asm("nop"); vsfsm_pt_delay(pt, 1000); asm("nop"); } vsfsm_pt_end(pt); return VSFERR_NONE; }