vsf_err_t vsfmal_write(struct vsfsm_pt_t *pt, vsfsm_evt_t evt, uint64_t addr, uint8_t *buff, uint32_t size) { struct vsfmal_t *mal = (struct vsfmal_t *)pt->user_data; uint32_t offset; vsf_err_t err; vsfsm_pt_begin(pt); mal->op_block_size = mal->drv->block_size(mal, addr, size, VSFMAL_OP_WRITE); mal->offset = 0; while (mal->offset < size) { mal->pt.user_data = mal; mal->pt.state = 0; vsfsm_pt_entry(pt); offset = mal->offset; err = mal->drv->write(&mal->pt, evt, addr + offset, buff + offset, mal->op_block_size); if (err != 0) return err; mal->offset += mal->op_block_size; } vsfsm_pt_end(pt); return VSFERR_NONE; }
static vsf_err_t vsf_malstream_write_thread(struct vsfsm_pt_t *pt, vsfsm_evt_t evt) { struct vsf_malstream_t *malstream = (struct vsf_malstream_t *)pt->user_data; struct vsfmal_t *mal = malstream->mal; struct vsf_stream_t *stream = (struct vsf_stream_t *)malstream->mbufstream; uint64_t cur_addr; vsf_err_t err; vsfsm_pt_begin(pt); mal->op_block_size = mal->drv->block_size(mal, malstream->addr, 0, VSFMAL_OP_WRITE); if (mal->op_block_size != malstream->mbufstream->mem.multibuf.size) { return VSFERR_BUG; } mal->pt.user_data = mal; malstream->offset = 0; while (malstream->offset < malstream->size) { while (stream_get_data_size(stream) < mal->op_block_size) { vsfsm_pt_wfe(pt, VSF_MALSTREAM_ON_INOUT); } mal->pt.state = 0; vsfsm_pt_entry(pt); cur_addr = malstream->addr + malstream->offset; err = mal->drv->write(&mal->pt, evt, cur_addr, vsf_multibuf_get_payload(&malstream->mbufstream->mem.multibuf), mal->op_block_size); if (err > 0) return err; else if (err < 0) goto end; vsf_multibuf_pop(&malstream->mbufstream->mem.multibuf); malstream->offset += mal->op_block_size; if (malstream->offset >= malstream->size) { // fix before callback stream->callback_tx.on_inout = NULL; } if (stream->tx_ready && (stream->callback_tx.on_inout != NULL)) { stream->callback_tx.on_inout(stream->callback_tx.param); } } end: if (malstream->cb.on_finish != NULL) { malstream->cb.on_finish(malstream->cb.param); } vsfsm_pt_end(pt); return VSFERR_NONE; }
static vsf_err_t vsfip_telnetd_session_rx_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_rxpt.sm = pt->sm; while (!session->disconnect) { session->caller_rxpt.state = 0; vsfsm_pt_entry(pt); err = vsfip_tcp_recv(&session->caller_rxpt, evt, session->so, &session->so->remote_sockaddr, &session->inbuf); if (err > 0) return err; else if (err < 0) { session->disconnect = true; // fake on_in event, just to wakeup tx_thread to exit vsfip_telnetd_session_stream_on_in(session); break; } while (session->inbuf->app.size > 0) { len = stream_write(session->stream_rx, &session->inbuf->app); if (!len && vsfsm_sem_pend(&session->stream_rx_sem, pt->sm)) { vsfsm_pt_wfe(pt, VSFIP_TELNETD_EVT_STREAM_OUT); continue; } session->inbuf->app.buffer += len; session->inbuf->app.size -= len; } vsfip_buffer_release(session->inbuf); } 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; }
static vsf_err_t vsfip_telnetd_thread(struct vsfsm_pt_t *pt, vsfsm_evt_t evt) { struct vsfip_telnetd_t *telnetd = (struct vsfip_telnetd_t *)pt->user_data; vsf_err_t err = VSFERR_NONE; int i; vsfsm_pt_begin(pt); telnetd->caller_pt.sm = pt->sm; telnetd->so = vsfip_socket(AF_INET, IPPROTO_TCP); if (NULL == telnetd->so) { return VSFERR_FAIL; } if ((vsfip_bind(telnetd->so, telnetd->port) != 0) || (vsfip_listen(telnetd->so, telnetd->session_num) != 0)) { err = VSFERR_FAIL; goto fail_socket_connect; } while (1) { telnetd->caller_pt.state = 0; vsfsm_pt_entry(pt); err = vsfip_tcp_accept(&telnetd->caller_pt, evt, telnetd->so, &telnetd->cur_session); if (err > 0) return err; else if (err < 0) { continue; } // get session for (i = 0; i < telnetd->session_num; i++) { if (!telnetd->sessions[i].connected) { struct vsfip_telnetd_session_t *session = &telnetd->sessions[i]; session->connected = true; session->disconnect = false; session->so = telnetd->cur_session; session->stream_rx->callback_tx.param = session; session->stream_rx->callback_tx.on_inout = vsfip_telnetd_session_stream_on_out; session->stream_tx->callback_rx.param = session; session->stream_tx->callback_rx.on_inout = vsfip_telnetd_session_stream_on_in; stream_connect_tx(session->stream_rx); stream_connect_rx(session->stream_tx); vsfsm_sem_init(&session->stream_tx_sem, 0, VSFIP_TELNETD_EVT_STREAM_IN); vsfsm_sem_init(&session->stream_rx_sem, 0, VSFIP_TELNETD_EVT_STREAM_OUT); session->txpt.thread = vsfip_telnetd_session_tx_thread; session->txpt.user_data = session; session->rxpt.thread = vsfip_telnetd_session_rx_thread; session->rxpt.user_data = session; vsfsm_pt_init(&session->txsm, &session->txpt); vsfsm_pt_init(&session->rxsm, &session->rxpt); break; } } if (i == telnetd->session_num) { telnetd->caller_pt.state = 0; vsfsm_pt_entry(pt); err = vsfip_tcp_close(&telnetd->caller_pt, evt, telnetd->cur_session); if (err > 0) return err; vsfip_close(telnetd->cur_session); } } fail_socket_connect: vsfip_close(telnetd->so); telnetd->so = NULL; 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; }