static vsf_err_t s6b0724_drv_parse_interface(struct dal_info_t *info, uint8_t *buff)
{
struct s6b0724_drv_interface_t *ifs = (struct s6b0724_drv_interface_t *)info->ifs;
ifs->ebi_port = buff[0];
ifs->lcd_index = buff[1];
ifs->cmd_addr = GET_LE_U32(&buff[2]);
ifs->data_addr = GET_LE_U32(&buff[6]);
return VSFERR_NONE;
}
static vsf_err_t vsfusbd_CDCACMControl_request_process(struct vsfusbd_device_t *device)
{
struct vsfusbd_ctrl_handler_t *ctrl_handler = &device->ctrl_handler;
struct vsf_buffer_t *buffer = &ctrl_handler->bufstream.mem.buffer;
struct usb_ctrlrequest_t *request = &ctrl_handler->request;
uint8_t iface = request->wIndex;
struct vsfusbd_config_t *config = &device->config[device->configuration];
struct vsfusbd_CDCACM_param_t *param =
(struct vsfusbd_CDCACM_param_t *)config->iface[iface].protocol_param;
if (USB_CDCACMREQ_SET_LINE_CODING == request->bRequest)
{
struct usb_CDCACM_line_coding_t *line_coding = ¶m->line_coding;
line_coding->bitrate = GET_LE_U32(&buffer->buffer[0]);
line_coding->stopbittype = buffer->buffer[4];
line_coding->paritytype = buffer->buffer[5];
line_coding->datatype = buffer->buffer[6];
if ((param->callback.set_line_coding != NULL) &&
(param->callback.set_line_coding(line_coding)))
{
return VSFERR_FAIL;
}
vsfusbd_CDCData_connect(¶m->CDC);
}
else
{
return vsfusbd_CDCControl_class.request_process(device);
}
return VSFERR_NONE;
}
static vsf_err_t vsfusbd_CDCACMControl_SetLineCoding_process(
struct vsfusbd_device_t *device, struct vsf_buffer_t *buffer)
{
struct usb_ctrl_request_t *request = &device->ctrl_handler.request;
uint8_t iface = request->index;
struct vsfusbd_config_t *config = &device->config[device->configuration];
struct vsfusbd_CDCACM_param_t *param =
(struct vsfusbd_CDCACM_param_t *)config->iface[iface].protocol_param;
struct vsfusbd_CDCACM_line_coding_t *line_coding = ¶m->line_coding;
line_coding->bitrate = GET_LE_U32(&buffer->buffer[0]);
line_coding->stopbittype = buffer->buffer[4];
line_coding->paritytype = buffer->buffer[5];
line_coding->datatype = buffer->buffer[6];
if ((param->callback.set_line_coding != NULL) &&
(param->callback.set_line_coding(line_coding)))
{
return VSFERR_FAIL;
}
vsfusbd_CDCData_connect(¶m->CDC_param);
return VSFERR_NONE;
}
void USB_TO_ADC_ProcessCmd(uint8_t *dat, uint16_t len)
{
uint16_t index, length;
uint8_t command, device_idx;
uint32_t clock_hz;
uint8_t mode;
uint8_t channel;
uint8_t cycles;
uint32_t adc_result;
index = 0;
while(index < len)
{
command = dat[index] & USB_TO_XXX_CMDMASK;
device_idx = dat[index] & USB_TO_XXX_IDXMASK;
length = GET_LE_U16(&dat[index + 1]);
index += 3;
switch(command)
{
case USB_TO_XXX_INIT:
if (0 == device_idx)
{
interfaces->adc.init(0);
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
break;
case USB_TO_XXX_CONFIG:
if (0 == device_idx)
{
clock_hz = GET_LE_U32(&dat[index]);
mode = dat[index + 4];
interfaces->adc.config(0, clock_hz, mode);
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
break;
case USB_TO_XXX_FINI:
if (0 == device_idx)
{
interfaces->adc.fini(0);
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
break;
case USB_TO_XXX_IN_OUT:
if (0 == device_idx)
{
channel = dat[index + 0];
interfaces->adc.sample(0, channel, &adc_result);
buffer_reply[rep_len++] = USB_TO_XXX_OK;
SET_LE_U32(&buffer_reply[rep_len], adc_result);
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
rep_len += 4;
break;
case USB_TO_XXX_OUT:
if (0 == device_idx)
{
channel = dat[index + 0];
cycles = dat[index + 1];
interfaces->adc.config_channel(0, channel, cycles);
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
break;
case USB_TO_XXX_SPECIAL:
if (0 == device_idx)
{
channel = dat[index + 0];
interfaces->adc.calibrate(0, channel);
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
break;
default:
buffer_reply[rep_len++] = USB_TO_XXX_CMD_NOT_SUPPORT;
break;
}
index += length;
}
}
void USB_TO_JTAG_LL_ProcessCmd(uint8_t *dat, uint16_t len)
{
uint16_t index, length;
uint8_t command, device_idx;
uint8_t para;
uint32_t cur_dat_len;
index = 0;
while(index < len)
{
command = dat[index] & USB_TO_XXX_CMDMASK;
device_idx = dat[index] & USB_TO_XXX_IDXMASK;
length = GET_LE_U16(&dat[index + 1]);
index += 3;
switch(command)
{
case USB_TO_XXX_INIT:
if (app_interfaces.jtag_ll.init(device_idx))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
case USB_TO_XXX_CONFIG:
if (app_interfaces.jtag_ll.config(device_idx,
GET_LE_U32(&dat[index])))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
case USB_TO_XXX_FINI:
if (app_interfaces.jtag_ll.fini(device_idx))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
case USB_TO_JTAG_LL_SCAN:
cur_dat_len = GET_LE_U16(&dat[index]);
para = cur_dat_len >> 15;
cur_dat_len &= 0x7FFF;
if (app_interfaces.jtag_ll.scan(device_idx, &dat[index + 2 + para],
cur_dat_len * 8, para, dat[index + 2],
dat[index + 2 + cur_dat_len + para],
dat[index + 2 + cur_dat_len + para + 1]))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
memcpy(&buffer_reply[rep_len], &dat[index + 2 + para],
cur_dat_len);
}
rep_len += cur_dat_len;
break;
case USB_TO_JTAG_LL_TMS:
if (app_interfaces.jtag_ll.tms(device_idx, &dat[index], length))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
case USB_TO_JTAG_LL_TMS_CLOCKS:
para = dat[index];
cur_dat_len = GET_LE_U32(&dat[index + 1]);
if (app_interfaces.jtag_ll.tms_clocks(device_idx, cur_dat_len,
para))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
default:
buffer_reply[rep_len++] = USB_TO_XXX_CMD_NOT_SUPPORT;
break;
}
index += length;
}
}
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;
}
void USB_TO_MSP430_JTAG_ProcessCmd(uint8_t *dat, uint16_t len)
{
uint16_t index, length;
uint8_t command, device_idx;
uint32_t data, mask, value;
uint16_t len_tmp;
uint8_t byte_len, bit_len;
bool fail;
uint16_t rindex;
index = 0;
while(index < len)
{
command = dat[index] & USB_TO_XXX_CMDMASK;
device_idx = dat[index] & USB_TO_XXX_IDXMASK;
length = GET_LE_U16(&dat[index + 1]);
index += 3;
switch(command)
{
case USB_TO_XXX_INIT:
if (app_interfaces.msp430jtag.init(device_idx))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
case USB_TO_XXX_CONFIG:
if (app_interfaces.msp430jtag.config(device_idx, dat[index]))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
case USB_TO_XXX_FINI:
if (app_interfaces.msp430jtag.fini(device_idx))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
case USB_TO_MSP430_JTAG_TCLK:
if (app_interfaces.msp430jtag.tclk(device_idx, dat[index]))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
case USB_TO_MSP430_JTAG_IRDR:
fail = false;
len_tmp = 0;
rindex = rep_len++;
while(len_tmp < length)
{
bit_len = dat[index + len_tmp + 0];
byte_len = ((bit_len & 0x7F) + 7) >> 3;
if(bit_len & 0x80)
{
// DR
data = 0;
memcpy((uint8_t*)&data, dat + index + len_tmp + 1,
byte_len);
if (app_interfaces.msp430jtag.dr(device_idx, &data,
bit_len & 0x7F, 1))
{
fail = true;
break;
}
else
{
memcpy(buffer_reply + rep_len, &data, byte_len);
}
rep_len += byte_len;
len_tmp += 1 + byte_len;
}
else
{
// IR
if (app_interfaces.msp430jtag.ir(device_idx,
&dat[index + len_tmp + 1], 1))
{
fail = true;
break;
}
else
{
buffer_reply[rep_len++] = dat[index + len_tmp + 1];
}
len_tmp += 2;
}
}
if (fail)
{
buffer_reply[rindex] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rindex] = USB_TO_XXX_OK;
}
break;
case USB_TO_MSP430_JTAG_Poll:
len_tmp = GET_LE_U16(&dat[index + 1]);
data = GET_LE_U32(&dat[index + 3]);
mask = GET_LE_U32(&dat[index + 7]);
value = GET_LE_U32(&dat[index + 11]);
if (app_interfaces.msp430jtag.poll(device_idx, data, mask, value,
dat[index], len_tmp & 0x7FFF, (len_tmp & 0x8000) > 0))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
case USB_TO_MSP430_JTAG_TCLK_STROBE:
if (app_interfaces.msp430jtag.tclk_strobe(device_idx,
GET_LE_U16(&dat[index])))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
case USB_TO_MSP430_JTAG_Reset:
if (app_interfaces.msp430jtag.reset(device_idx))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
default:
buffer_reply[rep_len++] = USB_TO_XXX_CMD_NOT_SUPPORT;
break;
}
index += length;
}
}
void USB_TO_EBI_ProcessCmd(uint8_t *dat, uint16_t len)
{
uint16_t index, length;
uint8_t command, device_idx;
uint8_t target_index;
uint8_t target_type;
uint8_t data_size;
uint32_t address, count;
struct ebi_sram_psram_nor_info_t nor_info;
struct ebi_nand_info_t nand_info;
vsf_err_t ret;
index = 0;
while(index < len)
{
command = dat[index] & USB_TO_XXX_CMDMASK;
device_idx = dat[index] & USB_TO_XXX_IDXMASK;
length = GET_LE_U16(&dat[index + 1]);
index += 3;
switch(command)
{
case USB_TO_XXX_INIT:
if (interfaces->ebi.init(device_idx))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
case USB_TO_XXX_CONFIG:
target_index = dat[index + 0];
target_type = target_index & 0xF0;
switch (target_type)
{
case EBI_TGTTYP_NOR:
nor_info.common_info.data_width = dat[index + 1];
nor_info.common_info.wait_signal =
(enum wait_signal_t)dat[index + 2];
nand_info.common_info.mux_addr_mask = 0;
nor_info.param.addr_multiplex = dat[index + 3];
nor_info.param.timing.address_setup_cycle_r =
GET_LE_U16(&dat[index + 4]);
nor_info.param.timing.address_hold_cycle_r =
GET_LE_U16(&dat[index + 6]);
nor_info.param.timing.data_setup_cycle_r =
GET_LE_U16(&dat[index + 8]);
nor_info.param.timing.clock_hz_r =
GET_LE_U32(&dat[index + 10]);
nor_info.param.timing.address_setup_cycle_w =
GET_LE_U16(&dat[index + 14]);
nor_info.param.timing.address_hold_cycle_w =
GET_LE_U16(&dat[index + 16]);
nor_info.param.timing.data_setup_cycle_w =
GET_LE_U16(&dat[index + 18]);
nor_info.param.timing.clock_hz_w = GET_LE_U32(&dat[index + 20]);
if (app_interfaces.ebi.config(device_idx, target_index,
&nor_info))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
case EBI_TGTTYP_NAND:
nand_info.common_info.data_width = dat[index + 1];
nand_info.common_info.wait_signal =
(enum wait_signal_t)dat[index + 2];
nand_info.common_info.mux_addr_mask = 0;
nand_info.param.clock_hz = GET_LE_U32(&dat[index + 3]);
nand_info.param.ecc.ecc_enable = dat[index + 7];
nand_info.param.ecc.ecc_page_size = GET_LE_U16(&dat[index + 8]);
nand_info.param.timing.ale_to_re_cycle = dat[index + 10];
nand_info.param.timing.cle_to_re_cycle = dat[index + 11];
nand_info.param.timing.setup_cycle =
GET_LE_U16(&dat[index + 12]);
nand_info.param.timing.wait_cycle =
GET_LE_U16(&dat[index + 14]);
nand_info.param.timing.hold_cycle = dat[index + 16];
nand_info.param.timing.hiz_cycle = dat[index + 17];
nand_info.param.timing.setup_cycle_attr =
GET_LE_U16(&dat[index + 18]);
nand_info.param.timing.wait_cycle_attr =
GET_LE_U16(&dat[index + 20]);
nand_info.param.timing.hold_cycle_attr = dat[index + 22];
nand_info.param.timing.hiz_cycle_attr = dat[index + 23];
if (app_interfaces.ebi.config(device_idx, target_index,
&nand_info))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
default:
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
break;
case USB_TO_XXX_FINI:
if (interfaces->ebi.fini(device_idx))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
case USB_TO_XXX_STATUS:
target_index = dat[index + 0];
ret = app_interfaces.ebi.isready(device_idx, target_index);
switch (ret)
{
case VSFERR_NONE:
case VSFERR_NOT_READY:
buffer_reply[rep_len] = USB_TO_XXX_OK;
break;
case VSFERR_FAIL:
default:
buffer_reply[rep_len] = USB_TO_XXX_FAILED;
break;
}
buffer_reply[rep_len + 1] = (int8_t)ret;
rep_len += 2;
break;
case USB_TO_XXX_IN:
target_index = dat[index + 0];
data_size = dat[index + 1];
address = GET_LE_U32(&dat[index + 2]);
count = GET_LE_U32(&dat[index + 6]);
if (app_interfaces.ebi.read(device_idx, target_index,
address, data_size, &buffer_reply[rep_len + 1], count))
{
buffer_reply[rep_len] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len] = USB_TO_XXX_OK;
}
rep_len += 1 + data_size * count;
break;
case USB_TO_XXX_OUT:
target_index = dat[index + 0];
data_size = dat[index + 1];
address = GET_LE_U32(&dat[index + 2]);
count = GET_LE_U32(&dat[index + 6]);
if (app_interfaces.ebi.write(device_idx, target_index,
address, data_size, &dat[index + 10], count))
{
buffer_reply[rep_len++] = USB_TO_XXX_FAILED;
}
else
{
buffer_reply[rep_len++] = USB_TO_XXX_OK;
}
break;
default:
buffer_reply[rep_len++] = USB_TO_XXX_CMD_NOT_SUPPORT;
break;
}
index += length;
}
}
