예제 #1
0
파일: main.c 프로젝트: kevin988/vsf
int main(void)
{
	uint32_t app_main_ptr;
	
	vsf_leave_critical();
	
	// system initialize
	vsf_bufmgr_init(app.bufmgr_buffer, sizeof(app.bufmgr_buffer));
	core_interfaces.core.init(NULL);
	core_interfaces.tickclk.init();
	core_interfaces.tickclk.start();
	vsftimer_init();
	core_interfaces.tickclk.set_callback(app_tickclk_callback_int, NULL);
	
	if (app.hwcfg.key.port != IFS_DUMMY_PORT)
	{
		core_interfaces.gpio.init(app.hwcfg.key.port);
		core_interfaces.gpio.config_pin(app.hwcfg.key.port, app.hwcfg.key.port,
										GPIO_INPU);
	}
	if ((IFS_DUMMY_PORT == app.hwcfg.key.port) ||
		core_interfaces.gpio.get(app.hwcfg.key.port, 1 << app.hwcfg.key.pin))
	{
		// key release
		// load and call application
		app_main_ptr = *(uint32_t *)APP_MAIN_ADDR;
		if (app_main_ptr < 128 * 1024)
		{
			app_main_ptr += APP_MAIN_ADDR;
			((int (*)(struct app_hwcfg_t *hwcfg))app_main_ptr)(&app.hwcfg);
		}
		else
		{
			goto bootlaoder_init;
		}
	}
	else
	{
		// run bootloader
	bootlaoder_init:
		
	}
	
	while (1)
	{
		vsfsm_poll();
		
		vsf_enter_critical();
		if (!vsfsm_get_event_pending())
		{
			// sleep, will also enable interrupt
			core_interfaces.core.sleep(SLEEP_WFI);
		}
		else
		{
			vsf_leave_critical();
		}
	}
}
예제 #2
0
파일: vsfsm.c 프로젝트: kevin988/vsf
vsf_err_t vsfsm_set_active(struct vsfsm_t *sm, bool active)
{
	vsf_enter_critical();
	sm->active = active;
	vsf_leave_critical();
	return VSFERR_NONE;
}
예제 #3
0
파일: vsfsm.c 프로젝트: kevin988/vsf
static vsf_err_t vsfsm_evtq_post(struct vsfsm_t *sm, vsfsm_evt_t evt)
{
	vsf_enter_critical();
	
	if (vsfsm_evt_count >= VSFSM_CFG_EVTQ_SIZE)
	{
		vsf_leave_critical();
		return VSFERR_NOT_ENOUGH_RESOURCES;
	}
	
	vsfsm_evtq_tail->sm = sm;
	vsfsm_evtq_tail->evt = evt;
	(vsfsm_evtq_tail == &vsfsm_evtq[VSFSM_CFG_EVTQ_SIZE - 1]) ?
		vsfsm_evtq_tail = &vsfsm_evtq[0] : vsfsm_evtq_tail++;
	sm->evt_count++;
	vsfsm_evt_count++;
	
	vsf_leave_critical();
	
	return VSFERR_NONE;
}
예제 #4
0
파일: core.c 프로젝트: a20084666/vsf
// sleep will enable interrupt
// for cortex processor, if an interrupt occur between enable the interrupt
// 		and __WFI, wfi will not make the core sleep
void cmem7_interface_sleep(uint32_t mode)
{
	// TODO
	vsf_leave_critical();
	/*
	if (mode == cmem7_SLEEP_WFI) // sleep
	{
		SCB->SCR &= ~0x4ul;
	}
	else // power down
	{
		SCB->SCR |= 0x4ul;
		CLK->PWRCTL |= CLK_PWRCTL_PDWKIF_Msk;
	}
	__WFI();
	*/
}
예제 #5
0
파일: vsfsm.c 프로젝트: kevin988/vsf
vsf_err_t vsfsm_poll(void)
{
	struct vsfsm_evtqueue_t tmp;
	
	while (vsfsm_evt_count)
	{
		tmp = *vsfsm_evtq_head;
		(vsfsm_evtq_head == &vsfsm_evtq[VSFSM_CFG_EVTQ_SIZE - 1]) ?
			vsfsm_evtq_head = &vsfsm_evtq[0] : vsfsm_evtq_head++;
		vsf_enter_critical();
		tmp.sm->evt_count--;
		vsfsm_evt_count--;
		vsf_leave_critical();
		vsfsm_dispatch_evt(tmp.sm, tmp.evt);
	}
	return VSFERR_NONE;
}
예제 #6
0
파일: NUC505_SDIO.c 프로젝트: versaloon/vsf
vsf_err_t nuc505_sdio_stop(uint8_t index)
{
	SD->CTL |= SDH_CTL_CTLRST_Msk;
	while (SD->CTL & SDH_CTL_CTLRST_Msk);
	SD->DMACTL |= SDH_DMACTL_DMARST_Msk;
	vsf_enter_critical();
	if (sdio_busy)
	{
		if (sdio_info)
			sdio_info->manual_stop = 1;

		sdio_busy = 0;
		sdio_callback(sdio_callback_param);
	}
	vsf_leave_critical();

	return VSFERR_NONE;
}
예제 #7
0
파일: vsf.c 프로젝트: ymwcoding/vsf
static void vsfsm_leave_critical_internal(void)
{
    vsf_leave_critical();
}
예제 #8
0
파일: vsfos.c 프로젝트: hank-fan/vsf
vsf_err_t vsfos_modinit(struct vsf_module_t *module,
								struct app_hwcfg_t const *cfg)
{
	struct vsfos_modifs_t *ifs;
	ifs = vsf_bufmgr_malloc(sizeof(struct vsfos_modifs_t));
	if (!ifs) return VSFERR_FAIL;
	memset(ifs, 0, sizeof(*ifs));

	ifs->hwcfg = cfg;

	ifs->pendsvq.size = dimof(ifs->pendsvq_ele);
	ifs->pendsvq.queue = ifs->pendsvq_ele;
	ifs->pendsvq.activate = vsfos_pendsv_activate;

	// init vsftimer
	ifs->vsftimer_memop.alloc = vsftimer_memop_alloc;
	ifs->vsftimer_memop.free = vsftimer_memop_free;

	// init fakefat32_fs
	ifs->fakefat32_fs.Windows_dir[0].memfile.file.name = ".";
	ifs->fakefat32_fs.Windows_dir[0].memfile.file.attr = VSFILE_ATTR_DIRECTORY;
	ifs->fakefat32_fs.Windows_dir[1].memfile.file.name = "..";
	ifs->fakefat32_fs.Windows_dir[1].memfile.file.attr = VSFILE_ATTR_DIRECTORY;
	ifs->fakefat32_fs.Windows_dir[2].memfile.file.name = "VSFCDC.inf";
	ifs->fakefat32_fs.Windows_dir[2].memfile.file.size = sizeof(vsfcdc_inf) - 1;
	ifs->fakefat32_fs.Windows_dir[2].memfile.file.attr = VSFILE_ATTR_ARCHIVE | VSFILE_ATTR_READONLY;
	ifs->fakefat32_fs.Windows_dir[2].memfile.f.buff = (uint8_t *)vsfcdc_inf;
	ifs->fakefat32_fs.Windows_dir[3].memfile.file.name = "VSFRNDIS.inf";
	ifs->fakefat32_fs.Windows_dir[3].memfile.file.size = sizeof(vsfrndis_inf) - 1;
	ifs->fakefat32_fs.Windows_dir[3].memfile.file.attr = VSFILE_ATTR_ARCHIVE | VSFILE_ATTR_READONLY;
	ifs->fakefat32_fs.Windows_dir[3].memfile.f.buff = (uint8_t *)vsfrndis_inf;

	ifs->fakefat32_fs.Driver_dir[0].memfile.file.name = ".";
	ifs->fakefat32_fs.Driver_dir[0].memfile.file.attr = VSFILE_ATTR_DIRECTORY;
	ifs->fakefat32_fs.Driver_dir[1].memfile.file.name = "..";
	ifs->fakefat32_fs.Driver_dir[1].memfile.file.attr = VSFILE_ATTR_DIRECTORY;
	ifs->fakefat32_fs.Driver_dir[2].memfile.file.name = "Windows";
	ifs->fakefat32_fs.Driver_dir[2].memfile.file.attr = VSFILE_ATTR_DIRECTORY;
	ifs->fakefat32_fs.Driver_dir[2].memfile.d.child = (struct vsfile_memfile_t *)ifs->fakefat32_fs.Windows_dir;

	ifs->fakefat32_fs.LOSTDIR_dir[0].memfile.file.name = ".";
	ifs->fakefat32_fs.LOSTDIR_dir[0].memfile.file.attr = VSFILE_ATTR_DIRECTORY;
	ifs->fakefat32_fs.LOSTDIR_dir[1].memfile.file.name = "..";
	ifs->fakefat32_fs.LOSTDIR_dir[1].memfile.file.attr = VSFILE_ATTR_DIRECTORY;

	ifs->fakefat32_fs.RECYCLEBIN_dir[0].memfile.file.name = ".";
	ifs->fakefat32_fs.RECYCLEBIN_dir[0].memfile.file.attr = VSFILE_ATTR_DIRECTORY;
	ifs->fakefat32_fs.RECYCLEBIN_dir[1].memfile.file.name = "..";
	ifs->fakefat32_fs.RECYCLEBIN_dir[1].memfile.file.attr = VSFILE_ATTR_DIRECTORY;
	ifs->fakefat32_fs.RECYCLEBIN_dir[2].memfile.file.name = "DESKTOP.INI";
	ifs->fakefat32_fs.RECYCLEBIN_dir[2].memfile.file.size = sizeof(Win_recycle_DESKTOP_INI) - 1;
	ifs->fakefat32_fs.RECYCLEBIN_dir[2].memfile.file.attr = VSFILE_ATTR_ARCHIVE | VSFILE_ATTR_READONLY;
	ifs->fakefat32_fs.RECYCLEBIN_dir[2].memfile.f.buff = (uint8_t *)Win_recycle_DESKTOP_INI;

	ifs->fakefat32_fs.SVI_dir[0].memfile.file.name = ".";
	ifs->fakefat32_fs.SVI_dir[0].memfile.file.attr = VSFILE_ATTR_DIRECTORY;
	ifs->fakefat32_fs.SVI_dir[1].memfile.file.name = "..";
	ifs->fakefat32_fs.SVI_dir[1].memfile.file.attr = VSFILE_ATTR_DIRECTORY;
	ifs->fakefat32_fs.SVI_dir[2].memfile.file.name = "IndexerVolumeGuid";
	ifs->fakefat32_fs.SVI_dir[2].memfile.file.size = sizeof(Win10_IndexerVolumeGuid);
	ifs->fakefat32_fs.SVI_dir[2].memfile.file.attr = VSFILE_ATTR_ARCHIVE | VSFILE_ATTR_READONLY | VSFILE_ATTR_SYSTEM | VSFILE_ATTR_HIDDEN,
	ifs->fakefat32_fs.SVI_dir[2].memfile.f.buff = (uint8_t *)Win10_IndexerVolumeGuid;
	ifs->fakefat32_fs.SVI_dir[3].memfile.file.name = "WPSettings.dat";
	ifs->fakefat32_fs.SVI_dir[3].memfile.file.size = sizeof(Win10_WPSettings_dat);
	ifs->fakefat32_fs.SVI_dir[3].memfile.file.attr = VSFILE_ATTR_ARCHIVE | VSFILE_ATTR_READONLY | VSFILE_ATTR_SYSTEM | VSFILE_ATTR_HIDDEN,
	ifs->fakefat32_fs.SVI_dir[3].memfile.f.buff = (uint8_t *)Win10_WPSettings_dat;

	ifs->fakefat32_fs.root_dir[0].memfile.file.name = "VSFDriver";
	ifs->fakefat32_fs.root_dir[0].memfile.file.attr = VSFILE_ATTR_VOLUMID;
	ifs->fakefat32_fs.root_dir[1].memfile.file.name = "LOST.DIR";
	ifs->fakefat32_fs.root_dir[1].memfile.file.attr = VSFILE_ATTR_DIRECTORY | VSFILE_ATTR_SYSTEM | VSFILE_ATTR_HIDDEN;
	ifs->fakefat32_fs.root_dir[1].memfile.d.child = (struct vsfile_memfile_t *)ifs->fakefat32_fs.LOSTDIR_dir;
	ifs->fakefat32_fs.root_dir[2].memfile.file.name = "$RECYCLE.BIN";
	ifs->fakefat32_fs.root_dir[2].memfile.file.attr = VSFILE_ATTR_DIRECTORY | VSFILE_ATTR_SYSTEM | VSFILE_ATTR_HIDDEN;
	ifs->fakefat32_fs.root_dir[2].memfile.d.child = (struct vsfile_memfile_t *)ifs->fakefat32_fs.RECYCLEBIN_dir;
	ifs->fakefat32_fs.root_dir[3].memfile.file.name = "System Volume Information";
	ifs->fakefat32_fs.root_dir[3].memfile.file.attr = VSFILE_ATTR_DIRECTORY | VSFILE_ATTR_SYSTEM | VSFILE_ATTR_HIDDEN;
	ifs->fakefat32_fs.root_dir[3].memfile.d.child = (struct vsfile_memfile_t *)ifs->fakefat32_fs.SVI_dir;
	ifs->fakefat32_fs.root_dir[4].memfile.file.name = "Driver";
	ifs->fakefat32_fs.root_dir[4].memfile.file.attr = VSFILE_ATTR_DIRECTORY;
	ifs->fakefat32_fs.root_dir[4].memfile.d.child = (struct vsfile_memfile_t *)ifs->fakefat32_fs.Driver_dir;

	// init fakefat32
	ifs->mal.fakefat32.sector_size = 512;
	ifs->mal.fakefat32.sector_number = 0x1000;
	ifs->mal.fakefat32.sectors_per_cluster = 8;
	ifs->mal.fakefat32.volume_id = 0xDEADBEEF;
	ifs->mal.fakefat32.disk_id = 0xBABECAFE;
	ifs->mal.fakefat32.root[0].memfile.file.name = "ROOT";
	ifs->mal.fakefat32.root[0].memfile.d.child = (struct vsfile_memfile_t *)ifs->fakefat32_fs.root_dir,

	// init mal
	ifs->mal.mal.drv = &fakefat32_mal_drv;
	ifs->mal.mal.param = &ifs->mal.fakefat32;
	ifs->mal.pbuffer[0] = ifs->mal.buffer[0];
	ifs->mal.pbuffer[1] = ifs->mal.buffer[1];

	// init file
	ifs->fs.memop.alloc_vfs = vsfos_vsfile_alloc_vfs;
	ifs->fs.memop.free_vfs = vsfos_vsfile_free_vfs;

	// init mal2scsi
	ifs->mal.scsistream.mbuf.count = dimof(ifs->mal.buffer);
	ifs->mal.scsistream.mbuf.size = sizeof(ifs->mal.buffer[0]);
	ifs->mal.scsistream.mbuf.buffer_list = ifs->mal.pbuffer;
	ifs->mal.mal2scsi.malstream.mal = &ifs->mal.mal;
	ifs->mal.mal2scsi.cparam.block_size = 512;
	ifs->mal.mal2scsi.cparam.removable = false;
	memcpy(ifs->mal.mal2scsi.cparam.vendor, "Simon   ", 8);
	memcpy(ifs->mal.mal2scsi.cparam.product, "VSFDriver       ", 16);
	memcpy(ifs->mal.mal2scsi.cparam.revision, "1.00", 4);
	ifs->mal.mal2scsi.cparam.type = SCSI_PDT_DIRECT_ACCESS_BLOCK;

	// init scsi device
	ifs->mal.lun[0].op = &vsf_mal2scsi_op;
	ifs->mal.lun[0].stream = (struct vsf_stream_t *)&ifs->mal.scsistream;
	ifs->mal.lun[0].param = &ifs->mal.mal2scsi;
	ifs->mal.scsi_dev.max_lun = 0;
	ifs->mal.scsi_dev.lun = ifs->mal.lun;

	// init rndis
	ifs->usbd.rndis.param.CDCACM.CDC.ep_notify = 1;
	ifs->usbd.rndis.param.CDCACM.CDC.ep_out = 2;
	ifs->usbd.rndis.param.CDCACM.CDC.ep_in = 2;
	ifs->usbd.rndis.param.mac.size = 6;
	ifs->usbd.rndis.param.mac.addr.s_addr64 = 0x0605040302E0;
	ifs->usbd.rndis.param.netif.macaddr.size = 6;
	ifs->usbd.rndis.param.netif.macaddr.addr.s_addr64 = 0x0E0D0C0B0AE0;
	ifs->usbd.rndis.param.cb.param = &ifs->usbd.rndis;
	ifs->usbd.rndis.param.cb.on_connect = vsfos_rndis_on_connect;
	if (0)
	{
		ifs->usbd.rndis.param.netif.ipaddr.size = 4;
		ifs->usbd.rndis.param.netif.ipaddr.addr.s_addr = 0x01202020;
		ifs->usbd.rndis.param.netif.netmask.size = 4;
		ifs->usbd.rndis.param.netif.netmask.addr.s_addr = 0x00FFFFFF;
		ifs->usbd.rndis.param.netif.gateway.size = 4;
		ifs->usbd.rndis.param.netif.gateway.addr.s_addr = 0x01202020;
	}

	// init cdc
	ifs->usbd.cdc.stream_tx.stream.op = &fifostream_op;
	ifs->usbd.cdc.stream_tx.mem.buffer.buffer = ifs->usbd.cdc.txbuff;
	ifs->usbd.cdc.stream_tx.mem.buffer.size = sizeof(ifs->usbd.cdc.txbuff);
	ifs->usbd.cdc.stream_rx.stream.op = &fifostream_op;
	ifs->usbd.cdc.stream_rx.mem.buffer.buffer = ifs->usbd.cdc.rxbuff;
	ifs->usbd.cdc.stream_rx.mem.buffer.size = sizeof(ifs->usbd.cdc.rxbuff);
	ifs->usbd.cdc.param.CDC.ep_notify = 3;
	ifs->usbd.cdc.param.CDC.ep_out = 4;
	ifs->usbd.cdc.param.CDC.ep_in = 4;
	ifs->usbd.cdc.param.CDC.stream_tx = (struct vsf_stream_t *)&ifs->usbd.cdc.stream_tx;
	ifs->usbd.cdc.param.CDC.stream_rx = (struct vsf_stream_t *)&ifs->usbd.cdc.stream_rx;
	ifs->usbd.cdc.param.line_coding.bitrate = 115200;
	ifs->usbd.cdc.param.line_coding.stopbittype = 0;
	ifs->usbd.cdc.param.line_coding.paritytype = 0;
	ifs->usbd.cdc.param.line_coding.datatype = 8;

	// init msc
	ifs->usbd.msc.param.ep_in = 5;
	ifs->usbd.msc.param.ep_out = 5;
	ifs->usbd.msc.param.scsi_dev = &ifs->mal.scsi_dev;

	// init usbd
	ifs->usbd.desc[0] = (struct vsfusbd_desc_filter_t)VSFUSBD_DESC_DEVICE(0, USB_DeviceDescriptor, sizeof(USB_DeviceDescriptor));
	ifs->usbd.desc[1] = (struct vsfusbd_desc_filter_t)VSFUSBD_DESC_CONFIG(0, 0, USB_ConfigDescriptor, sizeof(USB_ConfigDescriptor));
	ifs->usbd.desc[2] = (struct vsfusbd_desc_filter_t)VSFUSBD_DESC_STRING(0, 0, USB_StringLangID, sizeof(USB_StringLangID));
	ifs->usbd.desc[3] = (struct vsfusbd_desc_filter_t)VSFUSBD_DESC_STRING(0x0409, 1, USB_StringVendor, sizeof(USB_StringVendor));
	ifs->usbd.desc[4] = (struct vsfusbd_desc_filter_t)VSFUSBD_DESC_STRING(0x0409, 2, USB_StringProduct, sizeof(USB_StringProduct));
	ifs->usbd.desc[5] = (struct vsfusbd_desc_filter_t)VSFUSBD_DESC_STRING(0x0409, 3, USB_StringSerial, sizeof(USB_StringSerial));
	ifs->usbd.desc[6] = (struct vsfusbd_desc_filter_t)VSFUSBD_DESC_STRING(0x0409, 4, RNDIS_StringFunc, sizeof(RNDIS_StringFunc));
	ifs->usbd.desc[7] = (struct vsfusbd_desc_filter_t)VSFUSBD_DESC_STRING(0x0409, 5, CDC_StringFunc, sizeof(CDC_StringFunc));
	ifs->usbd.desc[8] = (struct vsfusbd_desc_filter_t)VSFUSBD_DESC_STRING(0x0409, 6, MSC_StringFunc, sizeof(MSC_StringFunc));
	ifs->usbd.ifaces[0].class_protocol = (struct vsfusbd_class_protocol_t *)&vsfusbd_RNDISControl_class;
	ifs->usbd.ifaces[0].protocol_param = &ifs->usbd.rndis.param;
	ifs->usbd.ifaces[1].class_protocol = (struct vsfusbd_class_protocol_t *)&vsfusbd_RNDISData_class;
	ifs->usbd.ifaces[1].protocol_param = &ifs->usbd.rndis.param;
	ifs->usbd.ifaces[2].class_protocol = (struct vsfusbd_class_protocol_t *)&vsfusbd_CDCACMControl_class;
	ifs->usbd.ifaces[2].protocol_param = &ifs->usbd.cdc.param;
	ifs->usbd.ifaces[3].class_protocol = (struct vsfusbd_class_protocol_t *)&vsfusbd_CDCACMData_class;
	ifs->usbd.ifaces[3].protocol_param = &ifs->usbd.cdc.param;
	ifs->usbd.ifaces[4].class_protocol = (struct vsfusbd_class_protocol_t *)&vsfusbd_MSCBOT_class;
	ifs->usbd.ifaces[4].protocol_param = &ifs->usbd.msc.param;
	ifs->usbd.config[0].num_of_ifaces = dimof(ifs->usbd.ifaces);
	ifs->usbd.config[0].iface = ifs->usbd.ifaces;
	ifs->usbd.device.num_of_configuration = dimof(ifs->usbd.config);
	ifs->usbd.device.config = ifs->usbd.config;
	ifs->usbd.device.desc_filter = ifs->usbd.desc;
	ifs->usbd.device.device_class_iface = 0;
	ifs->usbd.device.drv = vsfhal_usbd_if;
	ifs->usbd.device.int_priority = 0x01;

	// init telnetd
	ifs->tcpip.telnetd.telnetd.port = 23;
	ifs->tcpip.telnetd.telnetd.session_num = dimof(ifs->tcpip.telnetd.sessions);
	ifs->tcpip.telnetd.sessions[0].session.stream_tx = (struct vsf_stream_t *)&ifs->tcpip.telnetd.sessions[0].stream_tx;
	ifs->tcpip.telnetd.sessions[0].session.stream_rx = (struct vsf_stream_t *)&ifs->tcpip.telnetd.sessions[0].stream_rx;
	ifs->tcpip.telnetd.sessions[0].stream_tx.stream.op = &fifostream_op;
	ifs->tcpip.telnetd.sessions[0].stream_tx.mem.buffer.buffer = (uint8_t *)ifs->tcpip.telnetd.sessions[0].txbuff;
	ifs->tcpip.telnetd.sessions[0].stream_tx.mem.buffer.size = sizeof(ifs->tcpip.telnetd.sessions[0].txbuff);
	ifs->tcpip.telnetd.sessions[0].stream_rx.stream.op = &fifostream_op;
	ifs->tcpip.telnetd.sessions[0].stream_rx.mem.buffer.buffer = (uint8_t *)ifs->tcpip.telnetd.sessions[0].rxbuff;
	ifs->tcpip.telnetd.sessions[0].stream_rx.mem.buffer.size = sizeof(ifs->tcpip.telnetd.sessions[0].rxbuff);

	// init tcpip
	ifs->tcpip.mem_op.get_buffer = vsfos_vsfip_get_buffer;
	ifs->tcpip.mem_op.release_buffer = vsfos_vsfip_release_buffer;
	ifs->tcpip.mem_op.get_socket = vsfos_vsfip_get_socket;
	ifs->tcpip.mem_op.release_socket = vsfos_vsfip_release_socket;
	ifs->tcpip.mem_op.get_tcppcb = vsfos_vsfip_get_tcppcb;
	ifs->tcpip.mem_op.release_tcppcb = vsfos_vsfip_release_tcppcb;

	// init shell
	ifs->shell.echo = true;
	ifs->shell.stream_tx = (struct vsf_stream_t *)&ifs->usbd.cdc.stream_tx;
	ifs->shell.stream_rx = (struct vsf_stream_t *)&ifs->usbd.cdc.stream_rx;

	ifs->pt.user_data = ifs;
	ifs->pt.thread = vsfos_thread;
	module->ifs = ifs;

	vsfsm_evtq_init(&ifs->pendsvq);
	vsfsm_evtq_set(&ifs->pendsvq);
	vsfsm_pt_init(&ifs->sm, &ifs->pt);

	vsfhal_core_pendsv_config(vsfos_on_pendsv, &ifs->pendsvq);
	vsf_leave_critical();

	vsfsm_evtq_set(NULL);
	while (1)
	{
		// no thread runs in mainq, just sleep in main loop
		vsfhal_core_sleep(0);
	}
}
예제 #9
0
파일: core.c 프로젝트: kevin988/vsf
// sleep will enable interrupt
// for cortex processor, if an interrupt occur between enable the interrupt
// 		and __WFI, wfi will not make the core sleep
void stm32_interface_sleep(uint32_t mode)
{
	vsf_leave_critical();
	__WFI();
}