RESULT versaloon_get_target_voltage(uint16_t *voltage)
{
uint16_t inlen;
#if PARAM_CHECK
if (NULL == versaloon_buf) {
LOG_BUG(ERRMSG_INVALID_BUFFER, TO_STR(versaloon_buf));
return ERRCODE_INVALID_BUFFER;
}
if (NULL == voltage) {
LOG_BUG(ERRMSG_INVALID_PARAMETER, __func__);
return ERRCODE_INVALID_PARAMETER;
}
#endif
versaloon_buf[0] = VERSALOON_GET_TVCC;
if ((ERROR_OK != versaloon_send_command(1, &inlen)) || (inlen != 2)) {
LOG_ERROR(ERRMSG_FAILURE_OPERATION, "communicate with versaloon");
return ERRCODE_FAILURE_OPERATION;
} else {
*voltage = versaloon_buf[0] + (versaloon_buf[1] << 8);
return ERROR_OK;
}
}
static vsf_err_t at91sam3swj_iap_poll_result(struct at91sam3swj_iap_reply_t *reply)
{
uint32_t buff_tmp[256 + 4];
uint32_t data_size;
if (NULL == fail)
{
LOG_BUG(ERRMSG_INVALID_PARAMETER, __FUNCTION__);
return VSFERR_INVALID_PARAMETER;
}
if ((reply != NULL) && (reply->data_num > (dimof(buff_tmp) - 1)))
{
LOG_BUG("buff size is not enough for this call.");
return VSFERR_FAIL;
}
data_size = 4;
if (reply != NULL)
{
data_size = (1 + reply->data_num) * sizeof(uint32_t);
}
// read result and sync
// sync is 4-byte BEFORE result
if (adi_memap_read_buf(AT91SAM3_IAP_SYNC_ADDR,
(uint8_t *)buff_tmp, data_size))
{
LOG_ERROR(ERRMSG_FAILURE_OPERATION, "read iap sync");
return ERRCODE_FAILURE_OPERATION;
}
// buff_tmp[0] is sync, which is eefc_frr
if (buff_tmp[0] != 0)
{
if (buff_tmp[0] != 1)
{
cm_dump(AT91SAM3_IAP_BASE, sizeof(iap_code) + 256);
LOG_ERROR(ERRMSG_FAILURE_OPERATION_ERRCODE, "call iap",
buff_tmp[1]);
return ERRCODE_FAILURE_OPERATION;
}
if ((reply != NULL) && (reply->data != NULL))
{
memcpy(reply->data, &buff_tmp[1],
reply->data_num * sizeof(uint32_t));
}
return VSFERR_NONE;
}
return VSFERR_NOT_READY;
}
RESULT versaloon_add_pending(uint8_t type, uint8_t cmd, uint16_t actual_szie,
uint16_t want_pos, uint16_t want_size, uint8_t *buffer, uint8_t collect)
{
#if PARAM_CHECK
if (versaloon_pending_idx >= VERSALOON_MAX_PENDING_NUMBER) {
LOG_BUG(ERRMSG_INVALID_INDEX, versaloon_pending_idx,
"versaloon pending data");
return ERROR_FAIL;
}
#endif
versaloon_pending[versaloon_pending_idx].type = type;
versaloon_pending[versaloon_pending_idx].cmd = cmd;
versaloon_pending[versaloon_pending_idx].actual_data_size = actual_szie;
versaloon_pending[versaloon_pending_idx].want_data_pos = want_pos;
versaloon_pending[versaloon_pending_idx].want_data_size = want_size;
versaloon_pending[versaloon_pending_idx].data_buffer = buffer;
versaloon_pending[versaloon_pending_idx].collect = collect;
versaloon_pending[versaloon_pending_idx].id = versaloon_pending_id;
versaloon_pending_id = 0;
versaloon_pending[versaloon_pending_idx].extra_data = versaloon_extra_data;
versaloon_extra_data = NULL;
versaloon_pending[versaloon_pending_idx].callback = versaloon_callback;
versaloon_callback = NULL;
versaloon_pending[versaloon_pending_idx].pos = versaloon_want_pos;
versaloon_want_pos = NULL;
versaloon_pending_idx++;
return ERROR_OK;
}
static vsf_err_t parse_operation(uint32_t *operation, const char *opt,
uint32_t optlen)
{
uint32_t mask = 0, tmp;
uint32_t i;
#if PARAM_CHECK
if ((NULL == operation) || (NULL == opt))
{
LOG_BUG(ERRMSG_INVALID_PARAMETER, __FUNCTION__);
return VSFERR_INVALID_PARAMETER;
}
#endif
for (i = 0; i < optlen; i++)
{
tmp = target_area_mask(opt[i]);
if (tmp == 0)
{
LOG_ERROR(ERRMSG_INVALID_CHARACTER, opt[i], "target area");
return VSFERR_FAIL;
}
mask |= tmp;
}
*operation = mask;
return VSFERR_NONE;
}
vsf_err_t usbtobdm_transact(uint8_t index, uint8_t *out,
uint8_t outlen, uint8_t *in, uint8_t inlen, uint8_t delay, uint8_t ack)
{
uint16_t token;
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
if ((outlen > 0x0F) || (inlen > 0x0F) || (NULL == out) || (delay > 3))
{
return VSFERR_FAIL;
}
#endif
token = outlen | (inlen << 8) | (delay << 6) | (ack ? 0x8000 : 0x0000);
SET_LE_U16(&usbtoxxx_info->cmd_buff[0], token);
memcpy(&usbtoxxx_info->cmd_buff[2], out, outlen);
if (NULL == in)
{
return usbtoxxx_inout_command(USB_TO_BDM, index,
usbtoxxx_info->cmd_buff, 2 + outlen, inlen, NULL, 0, 0, 1);
}
else
{
return usbtoxxx_inout_command(USB_TO_BDM, index,
usbtoxxx_info->cmd_buff, 2 + outlen, inlen, in, 0, inlen, 1);
}
}
RESULT usbtojtagraw_execute(uint8_t interface_index, uint8_t *tdi,
uint8_t *tms, uint8_t *tdo, uint32_t bitlen)
{
uint16_t bytelen;
#if PARAM_CHECK
if (interface_index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, interface_index);
return ERROR_FAIL;
}
#endif
if (bitlen > 8 * 0xFFFF)
{
return ERROR_FAIL;
}
bytelen = (uint16_t)((bitlen + 7) >> 3);
SET_LE_U32(&versaloon_cmd_buf[0], bitlen);
memcpy(versaloon_cmd_buf + 4, tdi, bytelen);
memcpy(versaloon_cmd_buf + 4 + bytelen, tms, bytelen);
return usbtoxxx_inout_command(USB_TO_JTAG_RAW, interface_index,
versaloon_cmd_buf, 4 + bytelen * 2, bytelen, tdo, 0, bytelen, 0);
}
vsf_err_t usbtoswim_enable(uint8_t index)
{
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
#endif
return usbtoxxx_enable_command(USB_TO_SWIM, index, NULL, 0);
}
vsf_err_t usbtolpcicp_config(uint8_t index)
{
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
#endif
return usbtoxxx_conf_command(USB_TO_LPCICP, index, NULL, 0);
}
vsf_err_t usbtolpcicp_out(uint8_t index, uint8_t *buff, uint16_t len)
{
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
#endif
return usbtoxxx_out_command(USB_TO_LPCICP, index, buff, len, 0);
}
vsf_err_t usbtobdm_sync(uint8_t index, uint16_t *khz)
{
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
#endif
return usbtoxxx_sync_command(USB_TO_BDM, index, NULL, 0, 2,
(uint8_t *)khz);
}
RESULT versaloon_send_command(uint16_t out_len, uint16_t *inlen)
{
int ret;
#if PARAM_CHECK
if (NULL == versaloon_buf) {
LOG_BUG(ERRMSG_INVALID_BUFFER, TO_STR(versaloon_buf));
return ERRCODE_INVALID_BUFFER;
}
if ((0 == out_len) || (out_len > versaloon_interface.usb_setting.buf_size)) {
LOG_BUG(ERRMSG_INVALID_PARAMETER, __func__);
return ERRCODE_INVALID_PARAMETER;
}
#endif
ret = usb_bulk_write(versaloon_usb_device_handle,
versaloon_interface.usb_setting.ep_out, (char *)versaloon_buf,
out_len, versaloon_usb_to);
if (ret != out_len) {
LOG_ERROR(ERRMSG_FAILURE_OPERATION_ERRSTRING, "send usb data",
usb_strerror());
return ERRCODE_FAILURE_OPERATION;
}
if (inlen != NULL) {
ret = usb_bulk_read(versaloon_usb_device_handle,
versaloon_interface.usb_setting.ep_in, (char *)versaloon_buf,
versaloon_interface.usb_setting.buf_size, versaloon_usb_to);
if (ret > 0) {
*inlen = (uint16_t)ret;
return ERROR_OK;
} else {
LOG_ERROR(ERRMSG_FAILURE_OPERATION_ERRSTRING, "receive usb data",
usb_strerror());
return ERROR_FAIL;
}
} else
return ERROR_OK;
}
vsf_err_t usbtolpcicp_enter_program_mode(uint8_t index)
{
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
#endif
return usbtoxxx_inout_command(USB_TO_LPCICP, index, NULL,
0, 0, NULL, 0, 0, 0);
}
RESULT versaloon_send_command(uint16_t out_len, uint16_t *inlen)
{
int ret;
int transferred;
#if PARAM_CHECK
if (NULL == versaloon_buf) {
LOG_BUG(ERRMSG_INVALID_BUFFER, TO_STR(versaloon_buf));
return ERRCODE_INVALID_BUFFER;
}
if ((0 == out_len) || (out_len > versaloon_interface.usb_setting.buf_size)) {
LOG_BUG(ERRMSG_INVALID_PARAMETER, __func__);
return ERRCODE_INVALID_PARAMETER;
}
#endif
ret = libusb_bulk_transfer(versaloon_usb_device_handle,
versaloon_interface.usb_setting.ep_out,
versaloon_buf, out_len, &transferred, versaloon_usb_to);
if (0 != ret || transferred != out_len) {
LOG_ERROR(ERRMSG_FAILURE_OPERATION, "send usb data");
return ERRCODE_FAILURE_OPERATION;
}
if (inlen != NULL) {
ret = libusb_bulk_transfer(versaloon_usb_device_handle,
versaloon_interface.usb_setting.ep_in,
versaloon_buf, versaloon_interface.usb_setting.buf_size,
&transferred, versaloon_usb_to);
if (0 == ret) {
*inlen = (uint16_t)transferred;
return ERROR_OK;
} else {
LOG_ERROR(ERRMSG_FAILURE_OPERATION, "receive usb data");
return ERROR_FAIL;
}
} else
return ERROR_OK;
}
RESULT usbtojtagraw_config(uint8_t interface_index, uint32_t kHz)
{
uint8_t cfg_buf[4];
#if PARAM_CHECK
if (interface_index > 7) {
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, interface_index);
return ERROR_FAIL;
}
#endif
SET_LE_U32(&cfg_buf[0], kHz);
return usbtoxxx_conf_command(USB_TO_JTAG_RAW, interface_index, cfg_buf, 4);
}
vsf_err_t usbtomicrowire_transport(uint8_t index,
uint32_t opcode, uint8_t opcode_bitlen,
uint32_t addr, uint8_t addr_bitlen,
uint32_t data, uint8_t data_bitlen,
uint8_t *reply, uint8_t reply_bitlen)
{
uint8_t reply_bytelen = (reply_bitlen + 7) / 8;
uint16_t offset;
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
if ((opcode_bitlen > 32) || (addr_bitlen > 32) ||
(data_bitlen > 32) || (reply_bitlen > 32))
{
return VSFERR_FAIL;
}
#endif
usbtoxxx_info->cmd_buff[0] = opcode_bitlen;
usbtoxxx_info->cmd_buff[1] = addr_bitlen;
usbtoxxx_info->cmd_buff[2] = data_bitlen;
usbtoxxx_info->cmd_buff[3] = reply_bitlen;
offset = 4;
if (opcode_bitlen)
{
SET_LE_U32(&usbtoxxx_info->cmd_buff[offset], opcode);
offset += 4;
}
if (addr_bitlen)
{
SET_LE_U32(&usbtoxxx_info->cmd_buff[offset], addr);
offset += 4;
}
if (data_bitlen)
{
SET_LE_U32(&usbtoxxx_info->cmd_buff[offset], data);
offset += 4;
}
return usbtoxxx_inout_command(USB_TO_MICROWIRE, index,
usbtoxxx_info->cmd_buff, offset, reply_bytelen, reply,
0, reply_bytelen, 1);
}
RESULT usbtogpio_out(uint8_t interface_index, uint32_t mask, uint32_t value)
{
uint8_t buf[4];
#if PARAM_CHECK
if (interface_index > 7) {
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, interface_index);
return ERROR_FAIL;
}
#endif
SET_LE_U16(&buf[0], mask);
SET_LE_U16(&buf[2], value);
return usbtoxxx_out_command(USB_TO_GPIO, interface_index, buf, 4, 0);
}
vsf_err_t usbtogpio_in(uint8_t index, uint32_t mask, uint32_t *value)
{
uint8_t buf[2];
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
#endif
SET_LE_U16(&buf[0], mask);
return usbtoxxx_in_command(USB_TO_GPIO, index, buf, 2, 2,
(uint8_t*)value, 0, 2, 0);
}
vsf_err_t usbtoswim_sync(uint8_t index, uint8_t mHz)
{
uint8_t buff[1];
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
#endif
buff[0] = mHz;
return usbtoxxx_sync_command(USB_TO_SWIM, index, buff, 1,
0, NULL);
}
vsf_err_t usbtomicrowire_config(uint8_t index, uint16_t kHz,
uint8_t sel_polarity)
{
uint8_t conf[3];
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
#endif
conf[0] = sel_polarity;
SET_LE_U16(&conf[1], kHz);
return usbtoxxx_conf_command(USB_TO_MICROWIRE, index, conf, 3);
}
vsf_err_t usbtoswim_wotf(uint8_t index, uint8_t *data, uint16_t bytelen,
uint32_t addr)
{
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
#endif
SET_LE_U16(&usbtoxxx_info->cmd_buff[0], bytelen);
SET_LE_U32(&usbtoxxx_info->cmd_buff[2], addr);
memcpy(&usbtoxxx_info->cmd_buff[6], data, bytelen);
return usbtoxxx_out_command(USB_TO_SWIM, index,
usbtoxxx_info->cmd_buff, bytelen + 6, 0);
}
vsf_err_t usbtoswim_config(uint8_t index, uint8_t mHz, uint8_t cnt0,
uint8_t cnt1)
{
uint8_t buff[3];
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
#endif
buff[0] = mHz;
buff[1] = cnt0;
buff[2] = cnt1;
return usbtoxxx_conf_command(USB_TO_SWIM, index, buff, 3);
}
vsf_err_t usbtoswd_config(uint8_t index, uint8_t trn, uint16_t retry,
uint16_t dly)
{
uint8_t cfg_buf[5];
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
#endif
cfg_buf[0] = trn;
SET_LE_U16(&cfg_buf[1], retry);
SET_LE_U16(&cfg_buf[3], dly);
return usbtoxxx_conf_command(USB_TO_SWD, index, cfg_buf, 5);
}
vsf_err_t usbtomicrowire_poll(uint8_t index, uint16_t interval_us,
uint16_t retry_cnt)
{
uint8_t buff[4];
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
#endif
SET_LE_U16(&buff[0], interval_us);
SET_LE_U16(&buff[2], retry_cnt);
return usbtoxxx_poll_command(USB_TO_MICROWIRE, index, buff, 4,
NULL, 0);
}
vsf_err_t usbtogpio_config_pin(uint8_t index, uint8_t pin_idx,
uint8_t mode)
{
uint8_t conf[8];
uint32_t mask = 0, dir_mask = 0, pull_en_mask = 0, out_mask = 0;
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
if (pin_idx >= 32)
{
return VSFERR_FAIL;
}
#endif
mask = 1 << pin_idx;
if ((mode & USB_TO_GPIO_DIR_MSK) == USB_TO_GPIO_OUT)
{
dir_mask = mask;
}
if ((mode & USB_TO_GPIO_PULLEN_MSK) == USB_TO_GPIO_PULLEN)
{
pull_en_mask = mask;
}
if ((mode & USB_TO_GPIO_OUT_MSK) == USB_TO_GPIO_OUT1)
{
out_mask = mask;
}
dir_mask &= mask;
SET_LE_U16(&conf[0], mask);
SET_LE_U16(&conf[2], dir_mask);
SET_LE_U16(&conf[4], pull_en_mask);
SET_LE_U16(&conf[6], out_mask);
return usbtoxxx_conf_command(USB_TO_GPIO, index, conf,
sizeof(conf));
}
vsf_err_t usbtolpcicp_poll_ready(uint8_t index, uint8_t data,
uint8_t *ret, uint8_t setmask, uint8_t clearmask, uint16_t pollcnt)
{
uint8_t cmdbuf[5];
#if PARAM_CHECK
if (index > 7)
{
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, index);
return VSFERR_FAIL;
}
#endif
cmdbuf[0] = data;
cmdbuf[1] = setmask;
cmdbuf[2] = clearmask;
SET_LE_U16(&cmdbuf[3], pollcnt);
return usbtoxxx_poll_command(USB_TO_LPCICP, index, cmdbuf, 5,
ret, 1);
}
RESULT usbtogpio_config(uint8_t interface_index, uint32_t mask,
uint32_t dir_mask, uint32_t pull_en_mask,
uint32_t input_pull_mask)
{
uint8_t conf[8];
#if PARAM_CHECK
if (interface_index > 7) {
LOG_BUG(ERRMSG_INVALID_INTERFACE_NUM, interface_index);
return ERROR_FAIL;
}
#endif
dir_mask &= mask;
SET_LE_U16(&conf[0], mask);
SET_LE_U16(&conf[2], dir_mask);
SET_LE_U16(&conf[4], pull_en_mask);
SET_LE_U16(&conf[6], input_pull_mask);
return usbtoxxx_conf_command(USB_TO_GPIO, interface_index, conf,
sizeof(conf));
}
size_t HIR::TypeRef::get_size(size_t ofs) const
{
if( const auto* w = this->get_wrapper(ofs) )
{
switch(w->type)
{
case TypeWrapper::Ty::Array:
return this->get_size(1) * w->size;
case TypeWrapper::Ty::Borrow:
case TypeWrapper::Ty::Pointer:
if( const auto* next_w = this->get_wrapper(ofs+1) )
{
if( next_w->type == TypeWrapper::Ty::Slice )
{
return POINTER_SIZE*2;
}
else
{
return POINTER_SIZE;
}
}
else
{
// Need to look up the metadata type for the actual type
if( this->inner_type == RawType::Composite )
{
if( this->composite_type->dst_meta == RawType::Unreachable )
{
return POINTER_SIZE;
}
// Special case: extern types (which appear when a type is only ever used by pointer)
if( this->composite_type->dst_meta == RawType::Unit )
{
return POINTER_SIZE;
}
// TODO: Ideally, this inner type wouldn't be unsized itself... but checking that would be interesting.
return POINTER_SIZE + this->composite_type->dst_meta.get_size();
}
else if( this->inner_type == RawType::Str )
return POINTER_SIZE*2;
else if( this->inner_type == RawType::TraitObject )
return POINTER_SIZE*2;
else
{
return POINTER_SIZE;
}
}
case TypeWrapper::Ty::Slice:
LOG_BUG("Getting size of a slice - " << *this);
}
throw "";
}
else
{
switch(this->inner_type)
{
case RawType::Unit:
return 0;
case RawType::Composite:
// NOTE: Don't care if the type has metadata
return this->composite_type->size;
case RawType::Unreachable:
LOG_BUG("Attempting to get size of an unreachable type, " << *this);
case RawType::TraitObject:
case RawType::Str:
LOG_BUG("Attempting to get size of an unsized type, " << *this);
case RawType::U8: case RawType::I8:
return 1;
case RawType::U16: case RawType::I16:
return 2;
case RawType::U32: case RawType::I32:
return 4;
case RawType::U64: case RawType::I64:
return 8;
case RawType::U128: case RawType::I128:
return 16;
case RawType::Bool:
return 1;
case RawType::Char:
return 4;
case RawType::F32:
return 4;
case RawType::F64:
return 8;
case RawType::Function: // This should probably be invalid?
case RawType::USize: case RawType::ISize:
return POINTER_SIZE;
}
throw "";
}
}
