RESULT versaloon_init(void)
{
uint16_t ret = 0;
uint8_t retry;
uint32_t timeout_tmp;
/* malloc temporary buffer */
versaloon_buf =
(uint8_t *)malloc(versaloon_interface.usb_setting.buf_size);
if (NULL == versaloon_buf) {
LOG_ERROR(ERRMSG_NOT_ENOUGH_MEMORY);
return ERRCODE_NOT_ENOUGH_MEMORY;
}
/* connect to versaloon */
timeout_tmp = versaloon_usb_to;
/* not output error message when connectting */
/* 100ms delay when connect */
versaloon_usb_to = 100;
for (retry = 0; retry < VERSALOON_RETRY_CNT; retry++) {
versaloon_buf[0] = VERSALOON_GET_INFO;
if ((ERROR_OK == versaloon_send_command(1, &ret)) && (ret >= 3))
break;
}
versaloon_usb_to = timeout_tmp;
if (VERSALOON_RETRY_CNT == retry) {
versaloon_fini();
LOG_ERROR(ERRMSG_FAILURE_OPERATION, "communicate with versaloon");
return ERRCODE_FAILURE_OPERATION;
}
versaloon_buf[ret] = 0;
versaloon_buf_size = versaloon_buf[0] + (versaloon_buf[1] << 8);
versaloon_interface.usb_setting.buf_size = versaloon_buf_size;
LOG_INFO("%s", versaloon_buf + 2);
/* free temporary buffer */
free(versaloon_buf);
versaloon_buf = NULL;
versaloon_buf =
(uint8_t *)malloc(versaloon_interface.usb_setting.buf_size);
if (NULL == versaloon_buf) {
versaloon_fini();
LOG_ERROR(ERRMSG_NOT_ENOUGH_MEMORY);
return ERRCODE_NOT_ENOUGH_MEMORY;
}
versaloon_cmd_buf =
(uint8_t *)malloc(versaloon_interface.usb_setting.buf_size - 3);
if (NULL == versaloon_cmd_buf) {
versaloon_fini();
LOG_ERROR(ERRMSG_NOT_ENOUGH_MEMORY);
return ERRCODE_NOT_ENOUGH_MEMORY;
}
if (ERROR_OK != usbtoxxx_init()) {
LOG_ERROR(ERRMSG_FAILURE_OPERATION, "initialize usbtoxxx");
return ERROR_FAIL;
}
return versaloon_get_target_voltage(&ret);
}
static vsf_err_t versaloon_init(void *p)
{
struct interfaces_info_t *t = (struct interfaces_info_t *)p;
uint16_t ret = 0;
uint8_t retry;
vsf_err_t err = VSFERR_NONE;
if (t->comm->init())
{
return VSFERR_FAIL;
}
// malloc temporary buffer
if (!versaloon_usbtoxxx_info.buff_len)
{
versaloon_usbtoxxx_info.buff_len = 256;
}
versaloon_usbtoxxx_info.buff =
(uint8_t *)malloc(versaloon_usbtoxxx_info.buff_len);
if (NULL == versaloon_usbtoxxx_info.buff)
{
LOG_ERROR(ERRMSG_NOT_ENOUGH_MEMORY);
err = VSFERR_NOT_ENOUGH_RESOURCES;
goto versaloon_init_fail;
}
sleep_ms(100);
// connect to versaloon
LOG_PUSH();
LOG_MUTE();
// not output error message when connectting
// 500ms delay when connect
t->comm->set_timeout(100);
for (retry = 0; retry < VERSALOON_RETRY_CNT; retry++)
{
versaloon_usbtoxxx_info.buff[0] = VERSALOON_GET_INFO;
ret = versaloon_usbtoxxx_info.buff_len;
if (!t->comm->transact(versaloon_usbtoxxx_info.buff, 1,
versaloon_usbtoxxx_info.buff, &ret) &&
(ret >= 3))
{
break;
}
}
LOG_POP();
t->comm->set_timeout(VERSALOON_TIMEOUT);
if (VERSALOON_RETRY_CNT == retry)
{
LOG_ERROR(ERRMSG_FAILURE_OPERATION, "communicate with versaloon");
err = ERRCODE_FAILURE_OPERATION;
goto versaloon_init_fail;
}
versaloon_usbtoxxx_info.buff[ret] = 0;
versaloon_usbtoxxx_info.buff_len =
GET_LE_U16(&versaloon_usbtoxxx_info.buff[0]);
LOG_INFO("%s", &versaloon_usbtoxxx_info.buff[2]);
// free temporary buffer
free(versaloon_usbtoxxx_info.buff);
versaloon_usbtoxxx_info.buff = NULL;
usbtoxxx_info = &versaloon_usbtoxxx_info;
usbtoxxx_info->comm = t->comm;
if (usbtoxxx_init())
{
err = VSFERR_FAIL;
goto versaloon_init_fail;
}
// fixes programmer abilities
if (t != NULL)
{
if ((t->support_mask & IFS_CLOCK) &&
!usbtoxxx_interface_supported(USB_TO_CLKO))
{
t->support_mask &= ~IFS_CLOCK;
}
if ((t->support_mask & IFS_POLL) &&
!usbtoxxx_interface_supported(USB_TO_POLL))
{
t->support_mask &= ~IFS_POLL;
}
if ((t->support_mask & IFS_USART) &&
!usbtoxxx_interface_supported(USB_TO_USART))
{
t->support_mask &= ~IFS_USART;
}
if ((t->support_mask & IFS_SPI) &&
!usbtoxxx_interface_supported(USB_TO_SPI))
{
t->support_mask &= ~IFS_SPI;
}
if ((t->support_mask & IFS_EBI) &&
!usbtoxxx_interface_supported(USB_TO_EBI))
{
t->support_mask &= ~IFS_EBI;
}
if ((t->support_mask & IFS_I2C) &&
!usbtoxxx_interface_supported(USB_TO_I2C))
{
t->support_mask &= ~IFS_I2C;
}
if ((t->support_mask & IFS_GPIO) &&
!usbtoxxx_interface_supported(USB_TO_GPIO))
{
t->support_mask &= ~IFS_GPIO;
}
if ((t->support_mask & IFS_CAN) &&
!usbtoxxx_interface_supported(USB_TO_CAN))
{
t->support_mask &= ~IFS_CAN;
}
if ((t->support_mask & IFS_ADC) &&
!usbtoxxx_interface_supported(USB_TO_ADC))
{
t->support_mask &= ~IFS_ADC;
}
if ((t->support_mask & IFS_DAC) &&
!usbtoxxx_interface_supported(USB_TO_DAC))
{
t->support_mask &= ~IFS_DAC;
}
if ((t->support_mask & IFS_POWER) &&
!usbtoxxx_interface_supported(USB_TO_POWER))
{
t->support_mask &= ~IFS_POWER;
}
if ((t->support_mask & IFS_ISSP) &&
!usbtoxxx_interface_supported(USB_TO_ISSP))
{
t->support_mask &= ~IFS_ISSP;
}
if ((t->support_mask & IFS_JTAG_HL) &&
!usbtoxxx_interface_supported(USB_TO_JTAG_HL))
{
t->support_mask &= ~IFS_JTAG_HL;
}
if ((t->support_mask & IFS_JTAG_LL) &&
!usbtoxxx_interface_supported(USB_TO_JTAG_LL))
{
t->support_mask &= ~IFS_JTAG_LL;
}
if ((t->support_mask & IFS_MSP430_JTAG) &&
!usbtoxxx_interface_supported(USB_TO_MSP430_JTAG))
{
t->support_mask &= ~IFS_MSP430_JTAG;
}
if ((t->support_mask & IFS_C2) &&
!usbtoxxx_interface_supported(USB_TO_C2))
{
t->support_mask &= ~IFS_C2;
}
if ((t->support_mask & IFS_USART) &&
!usbtoxxx_interface_supported(USB_TO_USART))
{
t->support_mask &= ~IFS_USART;
}
if ((t->support_mask & IFS_LPC_ICP) &&
!usbtoxxx_interface_supported(USB_TO_LPCICP))
{
t->support_mask &= ~IFS_LPC_ICP;
}
if ((t->support_mask & IFS_SWD) &&
!usbtoxxx_interface_supported(USB_TO_SWD))
{
t->support_mask &= ~IFS_SWD;
}
if ((t->support_mask & IFS_SWIM) &&
!usbtoxxx_interface_supported(USB_TO_SWIM))
{
t->support_mask &= ~IFS_SWIM;
}
if ((t->support_mask & IFS_JTAG_RAW) &&
!usbtoxxx_interface_supported(USB_TO_JTAG_RAW))
{
t->support_mask &= ~IFS_JTAG_RAW;
}
if ((t->support_mask & IFS_BDM) &&
!usbtoxxx_interface_supported(USB_TO_BDM))
{
t->support_mask &= ~IFS_BDM;
}
if ((t->support_mask & IFS_DUSI) &&
!usbtoxxx_interface_supported(USB_TO_DUSI))
{
t->support_mask &= ~IFS_DUSI;
}
if ((t->support_mask & IFS_MICROWIRE) &&
!usbtoxxx_interface_supported(USB_TO_MICROWIRE))
{
t->support_mask &= ~IFS_MICROWIRE;
}
if ((t->support_mask & IFS_PWM) &&
!usbtoxxx_interface_supported(USB_TO_PWM))
{
t->support_mask &= ~IFS_PWM;
}
}
return VSFERR_NONE;
versaloon_init_fail:
versaloon_fini(t);
return err;
}
