static struct vsfsm_state_t *
vsfsm_top_handler(struct vsfsm_t *sm, vsfsm_evt_t evt)
{
REFERENCE_PARAMETER(sm);
REFERENCE_PARAMETER(evt);
return NULL;
}
static vsf_err_t embflash_drv_parse_interface(struct dal_info_t *info,
uint8_t *buff)
{
REFERENCE_PARAMETER(info);
REFERENCE_PARAMETER(buff);
return VSFERR_NONE;
}
static vsf_err_t cfi_drv_eraseblock_nb_start(struct dal_info_t *info,
uint64_t address, uint64_t count)
{
REFERENCE_PARAMETER(info);
REFERENCE_PARAMETER(address);
REFERENCE_PARAMETER(count);
return VSFERR_NONE;
}
static vsf_err_t cfi_drv_readblock_nb_isready(struct dal_info_t *info,
uint64_t address, uint8_t *buff)
{
REFERENCE_PARAMETER(info);
REFERENCE_PARAMETER(address);
REFERENCE_PARAMETER(buff);
return VSFERR_NONE;
}
static vsf_err_t s6b0724_drv_nb_start(struct dal_info_t *info,
uint64_t address, uint64_t count, uint8_t *buff)
{
REFERENCE_PARAMETER(info);
REFERENCE_PARAMETER(address);
REFERENCE_PARAMETER(count);
REFERENCE_PARAMETER(buff);
return VSFERR_NONE;
}
static vsf_err_t embflash_drv_eraseblock_nb_start(struct dal_info_t *info,
uint64_t address, uint64_t count)
{
struct embflash_param_t *param = (struct embflash_param_t *)info->param;
REFERENCE_PARAMETER(address);
REFERENCE_PARAMETER(count);
return interfaces->flash.unlock(param->index);
}
static vsf_err_t ee93cx6_drv_writeblock_waitready(struct dal_info_t *info,
uint64_t address, uint8_t *buff)
{
struct ee93cx6_drv_interface_t *ifs =
(struct ee93cx6_drv_interface_t *)info->ifs;
REFERENCE_PARAMETER(address);
REFERENCE_PARAMETER(buff);
return ee93cx6_drv_poll(ifs);
}
int32_t comm_ctrl_usbtocomm(uint8_t dtr, uint8_t rts)
{
REFERENCE_PARAMETER(dtr);
REFERENCE_PARAMETER(rts);
if ((NULL == prog) || !usbtocomm_open)
{
return -1;
}
return 0;
}
static vsf_err_t cfi_drv_writeblock_nb_start(struct dal_info_t *info,
uint64_t address, uint64_t count, uint8_t *buff)
{
REFERENCE_PARAMETER(info);
REFERENCE_PARAMETER(address);
REFERENCE_PARAMETER(count);
REFERENCE_PARAMETER(buff);
cfi_write_cmd(info, 0xAA, 2, 0x5555 << 1);
cfi_write_cmd(info, 0x55, 2, 0x2AAA << 1);
cfi_write_cmd(info, 0xF0, 2, 0x5555 << 1);
return VSFERR_NONE;
}
vsf_err_t comm_open_usbtocomm(char *comport, uint32_t baudrate,
uint8_t datalength, char paritybit, char stopbit, char handshake)
{
REFERENCE_PARAMETER(comport);
REFERENCE_PARAMETER(handshake);
// paritybit
usart_stream_p0.usart_info.baudrate = baudrate;
usart_stream_p0.usart_info.mode = 0;
switch (paritybit)
{
default:
case COMM_PARITYBIT_NONE:
usart_stream_p0.usart_info.mode |= USART_PARITY_NONE;
usart_stream_p0.usart_info.datalength = 8;
break;
case COMM_PARITYBIT_ODD:
usart_stream_p0.usart_info.mode |= USART_PARITY_ODD;
usart_stream_p0.usart_info.datalength = 9;
break;
case COMM_PARITYBIT_EVEN:
usart_stream_p0.usart_info.mode |= USART_PARITY_EVEN;
usart_stream_p0.usart_info.datalength = 9;
break;
}
// stopbit
switch (stopbit)
{
default:
case COMM_STOPBIT_1:
usart_stream_p0.usart_info.mode |= USART_STOPBITS_1;
break;
case COMM_STOPBIT_1P5:
usart_stream_p0.usart_info.mode |= USART_STOPBITS_1P5;
break;
case COMM_STOPBIT_2:
usart_stream_p0.usart_info.mode |= USART_STOPBITS_2;
break;
}
// initialize usbtocomm
if (usart_stream_init(&usart_stream_p0) ||
usart_stream_config(&usart_stream_p0))
{
return -1;
}
usbtocomm_open = 1;
return VSFERR_NONE;
}
vsf_err_t stm32_flash_write_isready(uint8_t index, uint32_t offset,
uint8_t *buff, uint32_t size)
{
REFERENCE_PARAMETER(offset);
REFERENCE_PARAMETER(buff);
REFERENCE_PARAMETER(size);
switch (index)
{
case 0:
return VSFERR_NONE;
default:
return VSFERR_NOT_SUPPORT;
}
}
static vsf_err_t cfi_drv_readblock_nb_start(struct dal_info_t *info,
uint64_t address, uint64_t count, uint8_t *buff)
{
struct cfi_drv_param_t *param = (struct cfi_drv_param_t *)info->param;
uint8_t data_width = param->nor_info.common_info.data_width / 8;
REFERENCE_PARAMETER(address);
REFERENCE_PARAMETER(count);
REFERENCE_PARAMETER(buff);
cfi_write_cmd(info, 0xAA, data_width, 0x0555 << 1);
cfi_write_cmd(info, 0x55, data_width, 0x02AA << 1);
cfi_write_cmd(info, 0xF0, data_width, 0);
return VSFERR_NONE;
}
vsf_err_t stm32_flash_erasepage_isready(uint8_t index, uint32_t offset)
{
volatile uint32_t *SR, *CR;
vsf_err_t err;
REFERENCE_PARAMETER(offset);
switch (index)
{
case 0:
if (offset < 512 * 1024)
{
CR = &FLASH->CR;
SR = &FLASH->SR;
}
else
{
CR = &FLASH->CR2;
SR = &FLASH->SR2;
}
err = ((*SR & STM32_FLASH_SR_BSY) == 0) ?
VSFERR_NONE : VSFERR_NOT_READY;
if (!err)
{
*CR &= ~STM32_FLASH_CR_PER;
}
return (*SR & STM32_FLASH_SR_WRPRTERR) ? VSFERR_FAIL : err;
default:
return VSFERR_NOT_SUPPORT;
}
}
static vsf_err_t embflash_drv_writeblock_nb(struct dal_info_t *info,
uint64_t address, uint8_t *buff)
{
struct embflash_param_t *param = (struct embflash_param_t *)info->param;
REFERENCE_PARAMETER(buff);
param->erased = false;
return interfaces->flash.erasepage(param->index, address);
}
vsf_err_t versaloon_get_target_voltage(uint8_t index, uint16_t *voltage)
{
REFERENCE_PARAMETER(index);
usbtopwr_init(index);
usbtopwr_config(index);
usbtopwr_get(index, voltage);
usbtopwr_fini(index);
return usbtoxxx_execute_command();
}
static vsf_err_t cfi_drv_eraseblock_nb_isready(struct dal_info_t *info,
uint64_t address)
{
uint32_t val1 = 0, val2 = 0;
struct cfi_drv_param_t *param = (struct cfi_drv_param_t *)info->param;
uint8_t data_width = param->nor_info.common_info.data_width / 8;
REFERENCE_PARAMETER(address);
cfi_read(info, 0x0000 << 1, data_width, (uint8_t *)&val1, 1);
cfi_read(info, 0x0000 << 1, data_width, (uint8_t *)&val2, 1);
interfaces->peripheral_commit();
return (((val1 ^ val2) & 0x0040) == 0) ? VSFERR_NONE : VSFERR_NOT_READY;
}
static vsf_err_t nuc400swj_iap_poll_param_taken(struct nuc400_fl_t *fl)
{
uint32_t sync;
REFERENCE_PARAMETER(fl);
// read sync
if (adi_memap_read_reg32(NUC400_IAP_SYNC_ADDR, &sync, 1))
{
LOG_ERROR(ERRMSG_FAILURE_OPERATION, "read iap sync");
return ERRCODE_FAILURE_OPERATION;
}
sync = LE_TO_SYS_U32(sync);
return (0 == sync) ? VSFERR_NONE : VSFERR_NOT_READY;
}
static vsf_err_t kinetisswj_iap_poll_result(struct kinetis_fl_t *fl,
struct kinetisswj_iap_rpl_t *result)
{
uint32_t result_buff[4];
REFERENCE_PARAMETER(fl);
if (adi_memap_read_buf32(KINETIS_IAP_SYNC_ADDR, (uint8_t *)result_buff,
sizeof(result_buff)))
{
LOG_ERROR(ERRMSG_FAILURE_OPERATION, "read iap sync");
return ERRCODE_FAILURE_OPERATION;
}
result->sync = LE_TO_SYS_U32(result_buff[0]);
result->iap_cnt = LE_TO_SYS_U32(result_buff[1]);
result->fail = LE_TO_SYS_U32(result_buff[2]);
result->result = LE_TO_SYS_U32(result_buff[3]);
return (0 == result->sync) ? VSFERR_NONE : VSFERR_NOT_READY;
}
static vsf_err_t cfi_drv_writeblock_nb_end(struct dal_info_t *info)
{
REFERENCE_PARAMETER(info);
return VSFERR_NONE;
}
uint32_t gd32f1x0_adc_get_max_value(uint8_t index)
{
REFERENCE_PARAMETER(index);
return (1 << 12) - 1;
}
static vsf_err_t ee93cx6_drv_readblock_nb_end(struct dal_info_t *info)
{
REFERENCE_PARAMETER(info);
return VSFERR_NONE;
}
static vsf_err_t versaloon_reset(void *p)
{
REFERENCE_PARAMETER(p);
return VSFERR_NONE;
}
vsf_err_t stream_fini(struct vsf_stream_t *stream)
{
REFERENCE_PARAMETER(stream);
return VSFERR_NONE;
}
static vsf_err_t s6b0724_drv_nb_end(struct dal_info_t *info)
{
REFERENCE_PARAMETER(info);
return VSFERR_NONE;
}
