int main(void)
{
uint32_t pagesize, pagenum, size;
uint32_t key_val;
interfaces->core.init(NULL);
if (!interfaces->flash.isprotected(0))
{
interfaces->flash.unlock(0);
interfaces->flash.protect(0);
interfaces->flash.lock(0);
}
if (mal.init(&embflash_dal_info) ||
(0 == embflash_mal_info.capacity.block_size) ||
(sizeof(block_buffer) < embflash_mal_info.capacity.block_size) ||
mal.readblock(&embflash_dal_info, APP_CFG_BOOTSIZE, block_buffer, 1))
{
fatal_error();
}
pagesize = (uint32_t)embflash_mal_info.capacity.block_size;
pagenum = (uint32_t)embflash_mal_info.capacity.block_number;
size = pagesize * pagenum;
// read MSP and RST_VECT
MSP = GET_LE_U32(&block_buffer[0]);
RST_VECT = GET_LE_U32(&block_buffer[4]);
interfaces->gpio.init(KEY_PORT);
interfaces->gpio.config_pin(KEY_PORT, KEY_PIN, KEY_VALID_LOW ? GPIO_INPU : GPIO_INPD);
key_val = interfaces->gpio.get(KEY_PORT, 1 << KEY_PIN);
if ((KEY_VALID_LOW ? key_val : !key_val) &&
((MSP & 0xFF000000) == 0x20000000) &&
((RST_VECT & 0xFF000000) == 0x08000000))
{
mal.fini(&embflash_dal_info);
interfaces->gpio.fini(KEY_PORT);
interfaces->core.set_stack(MSP);
((void (*)(void))RST_VECT)();
while (1);
}
interfaces->gpio.init(USB_PULL_PORT);
// Disable USB Pull-up
interfaces->gpio.clear(USB_PULL_PORT, 1 << USB_PULL_PIN);
interfaces->gpio.config_pin(USB_PULL_PORT, USB_PULL_PIN, GPIO_OUTPP);
// delay
interfaces->delay.delayms(200);
// fixes size for firmware.bin, config.bin, script.txt
#if EVSPROG_EN
if (size < (APP_CFG_BOOTSIZE + APP_CFG_FWSIZE + EVSPROG_TARGET_CFG_SIZE + EVSPROG_MAINSCRIPT_SIZE))
{
fatal_error();
}
ReadAppCfg(&app_cfg);
if ((app_cfg.main_script_size > EVSPROG_MAINSCRIPT_SIZE) ||
(app_cfg.slot_script_size[0] > EVSPROG_TARGETSCRIPT_SIZE) ||
(app_cfg.slot_script_size[1] > EVSPROG_TARGETSCRIPT_SIZE))
{
// initialize app_cfg
memset(&app_cfg, 0, sizeof(app_cfg));
WriteAppCfg(&app_cfg);
}
// firmware.bin
root_dir[ROOT_FIRMWARE_IDX].size = APP_CFG_FWSIZE;
// config.bin
root_dir[ROOT_CONFIG_IDX].size = EVSPROG_MAINSCRIPT_ADDR - EVSPROG_TARGET_CFG_ADDR;
// mainscript
root_dir[ROOT_MAINSCRIPT_IDX].size = app_cfg.main_script_size;
if (size > (APP_CFG_BOOTSIZE + APP_CFG_FWSIZE + EVSPROG_TARGET_CFG_SIZE + EVSPROG_MAINSCRIPT_SIZE))
{
// slot0 is embflash
slot_idx_embflash = 0;
evsprog_target_embflash_param.addr = APP_CFG_BOOTSIZE + APP_CFG_FWSIZE + EVSPROG_TARGET_CFG_SIZE + EVSPROG_MAINSCRIPT_SIZE;
evsprog_target_embflash_param.size = size - evsprog_target_embflash_param.addr - EVSPROG_TARGETSCRIPT_SIZE;
evsprog_script_embflash_param.addr = evsprog_target_embflash_param.addr + evsprog_target_embflash_param.size;
evsprog_script_embflash_param.size = EVSPROG_TARGETSCRIPT_SIZE;
target_slot_embflash_dir[TARGET_BIN_IDX].size = evsprog_target_embflash_param.size;
target_slot_embflash_dir[TARGET_SCRIPT_IDX].size = app_cfg.slot_script_size[slot_idx_embflash];
root_dir[ROOT_TARGETS_IDX + slot_idx_embflash].name = "slot0";
root_dir[ROOT_TARGETS_IDX + slot_idx_embflash].filelist = target_slot_embflash_dir;
}
else
{
slot_idx_embflash = -1;
}
// sst32hfxx parameter init
sst32hfxx_drv_param.nor_info.common_info.data_width = 16;
sst32hfxx_drv_param.nor_info.common_info.wait_signal = EBI_WAIT_NONE;
sst32hfxx_drv_param.nor_info.param.addr_multiplex = false;
sst32hfxx_drv_param.nor_info.param.timing.clock_hz_r =
sst32hfxx_drv_param.nor_info.param.timing.clock_hz_w = 0;
sst32hfxx_drv_param.nor_info.param.timing.address_setup_cycle_r =
sst32hfxx_drv_param.nor_info.param.timing.address_setup_cycle_w = 2;
sst32hfxx_drv_param.nor_info.param.timing.address_hold_cycle_r =
sst32hfxx_drv_param.nor_info.param.timing.address_hold_cycle_w = 0;
sst32hfxx_drv_param.nor_info.param.timing.data_setup_cycle_r =
sst32hfxx_drv_param.nor_info.param.timing.data_setup_cycle_w = 16;
sst32hfxx_drv_param.delayus = 20;
sst32hfxx_mal_info.capacity.block_size = 4096;
sst32hfxx_mal_info.capacity.block_number = 512;
if (!mal.init(&sst32hfxx_dal_info))
{
uint32_t extnor_pagesize = sst32hfxx_mal_info.capacity.block_size;
uint32_t extnor_size = (uint32_t)(
extnor_pagesize * sst32hfxx_mal_info.capacity.block_number);
// fix pagesize for fakefat32
pagesize = max(extnor_pagesize, pagesize);
slot_idx_extnor = 0;
if (slot_idx_embflash >= 0)
{
slot_idx_extnor = slot_idx_embflash + 1;
}
faktfat32_filename_slotn[4] = '0' + slot_idx_extnor;
// initialize extnor
evsprog_target_extnor_param.addr = 0;
evsprog_target_extnor_param.size = extnor_size - EVSPROG_TARGETSCRIPT_SIZE;
evsprog_script_extnor_param.addr = evsprog_target_extnor_param.size;
evsprog_script_extnor_param.size = EVSPROG_TARGETSCRIPT_SIZE;
target_slot_extnor_dir[TARGET_BIN_IDX].size = evsprog_target_extnor_param.size;
target_slot_extnor_dir[TARGET_SCRIPT_IDX].size = app_cfg.slot_script_size[slot_idx_extnor];
root_dir[ROOT_TARGETS_IDX + slot_idx_extnor].name = faktfat32_filename_slotn;
root_dir[ROOT_TARGETS_IDX + slot_idx_extnor].filelist = target_slot_extnor_dir;
}
else
{
slot_idx_extnor = -1;
}
#else
// firmware.bin
root_dir[ROOT_FIRMWARE_IDX].size = size - APP_CFG_BOOTSIZE;
#endif
mal.init(&firmware_dal_info);
#if EVSPROG_EN
mal.init(&evsprog_config_dal_info);
mal.init(&evsprog_mainscript_dal_info);
mal.init(&evsprog_target_extnor_dal_info);
mal.init(&evsprog_script_extnor_dal_info);
mal.init(&evsprog_target_embflash_dal_info);
mal.init(&evsprog_script_embflash_dal_info);
#endif
// fakefat32 parameter init
fakefat32_param.sector_size = pagesize;
fakefat32_param.sector_number = 128 * 1024 * 1024 / pagesize;
fakefat32_param.sectors_per_cluster = 1;
mal.init(&fakefat32_dal_info);
// Enable USB Pull-up
interfaces->gpio.set(USB_PULL_PORT, 1 << USB_PULL_PIN);
if (!vsfusbd_device_init(&usb_device))
{
while (1)
{
if (vsfusbd_device_poll(&usb_device))
{
break;
}
}
}
return 0;
}
// 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;
}
