You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
213 lines
6.0 KiB
213 lines
6.0 KiB
/*
|
|
* xsvftool-xpcu - An (X)SVF player for the Xilinx Platform Cable USB
|
|
*
|
|
* Copyright (C) 2011 RIEGL Research ForschungsGmbH
|
|
* Copyright (C) 2011 Clifford Wolf <clifford@clifford.at>
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include "fx2usb-interface.h"
|
|
|
|
usb_dev_handle *fx2usb_open(int vendor_id, int device_id, char *dev)
|
|
{
|
|
struct usb_bus *b;
|
|
struct usb_device *d;
|
|
char *dd = NULL;
|
|
int devlen;
|
|
|
|
if (dev) {
|
|
devlen = strlen(dev);
|
|
dd = devlen > 8 ? &dev[devlen-8] : "|xxx|xxx";
|
|
}
|
|
|
|
for (b = usb_get_busses(); b; b = b->next) {
|
|
for (d = b->devices; d; d = d->next) {
|
|
if (dd) {
|
|
if (dd[0] == '/' && !strncmp(dd+1, b->dirname, 3) &&
|
|
dd[4] == '/' && !strncmp(dd+5, d->filename, 3))
|
|
return usb_open(d);
|
|
} else
|
|
if (vendor_id || device_id) {
|
|
if ((d->descriptor.idVendor == vendor_id) && (d->descriptor.idProduct == device_id))
|
|
return usb_open(d);
|
|
} else {
|
|
// The Xilinx Platform Cable USB Vendor/Device IDs
|
|
if ((d->descriptor.idVendor == 0x03FD) && (d->descriptor.idProduct == 0x0009))
|
|
return usb_open(d);
|
|
if ((d->descriptor.idVendor == 0x03FD) && (d->descriptor.idProduct == 0x000D))
|
|
return usb_open(d);
|
|
if ((d->descriptor.idVendor == 0x03FD) && (d->descriptor.idProduct == 0x000F))
|
|
return usb_open(d);
|
|
// The plain CY7C68013 dev kit Vendor/Device IDs
|
|
if ((d->descriptor.idVendor == 0x04b4) && (d->descriptor.idProduct == 0x8613))
|
|
return usb_open(d);
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static int fx2usb_fwload_ctrl_msg(usb_dev_handle *dh, int addr, const void *data, int len)
|
|
{
|
|
int ret = usb_control_msg(dh, 0x40, 0xA0, addr, 0, (char*)data, len, 1000);
|
|
if (ret != len)
|
|
fprintf(stderr, "fx2usb_fwload_ctrl_msg: usb_control_msg for addr=0x%04X, len=%d returned %d: %s\n", addr, len, ret, ret >= 0 ? "NO ERROR" : usb_strerror());
|
|
return ret == len ? 0 : -1;
|
|
}
|
|
|
|
int fx2usb_upload_ihex(usb_dev_handle *dh, FILE *fp)
|
|
{
|
|
uint8_t on = 1, off = 0;
|
|
|
|
// assert reset
|
|
if (fx2usb_fwload_ctrl_msg(dh, 0xE600, &on, 1) < 0) {
|
|
fprintf(stderr, "fx2usb_upload_ihex: can't assert reset!\n");
|
|
return -1;
|
|
}
|
|
|
|
// parse and upload ihex file
|
|
char line[1024];
|
|
int linecount = 0;
|
|
while (fgets(line, sizeof(line), fp) != NULL)
|
|
{
|
|
linecount++;
|
|
|
|
if (line[0] != ':')
|
|
continue;
|
|
|
|
uint8_t cksum = 0;
|
|
uint8_t ldata[512];
|
|
int lsize = 0;
|
|
|
|
while (sscanf(line+1+lsize*2, "%2hhx", &ldata[lsize]) == 1) {
|
|
cksum += ldata[lsize];
|
|
lsize++;
|
|
}
|
|
|
|
if (lsize < 5) {
|
|
fprintf(stderr, "fx2usb_upload_ihex: ihex line %d: record is to short!\n", linecount);
|
|
return -1;
|
|
}
|
|
|
|
if (ldata[0] != lsize-5) {
|
|
fprintf(stderr, "fx2usb_upload_ihex: ihex line %d: size does not match record length!\n", linecount);
|
|
return -1;
|
|
}
|
|
|
|
cksum -= ldata[lsize-1];
|
|
cksum = ~cksum + 1;
|
|
|
|
if (cksum != ldata[lsize-1]) {
|
|
fprintf(stderr, "fx2usb_upload_ihex: ihex line %d: cksum error!\n", linecount);
|
|
return -1;
|
|
}
|
|
|
|
if (fx2usb_fwload_ctrl_msg(dh, (ldata[1] << 8) | ldata[2], &ldata[4], ldata[0]) < 0) {
|
|
fprintf(stderr, "fx2usb_upload_ihex: ihex line %d: error in fx2usb communication!\n", linecount);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
// release reset
|
|
if (fx2usb_fwload_ctrl_msg(dh, 0xE600, &off, 1) < 0) {
|
|
fprintf(stderr, "fx2usb_upload_ihex: can't release reset!\n");
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int fx2usb_claim(usb_dev_handle *dh)
|
|
{
|
|
#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
|
|
usb_detach_kernel_driver_np(dh, 0);
|
|
#endif
|
|
if (usb_claim_interface(dh, 0) < 0) {
|
|
fprintf(stderr, "fx2usb_claim: claiming interface 0 failed: %s!\n", usb_strerror());
|
|
return -1;
|
|
}
|
|
if (usb_set_altinterface(dh, 1) < 0) {
|
|
usb_release_interface(dh, 0);
|
|
fprintf(stderr, "fx2usb_claim: setting alternate interface 1 failed: %s!\n", usb_strerror());
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void fx2usb_release(usb_dev_handle *dh)
|
|
{
|
|
usb_release_interface(dh, 0);
|
|
}
|
|
|
|
void fx2usb_flush(usb_dev_handle *dh)
|
|
{
|
|
while (1)
|
|
{
|
|
unsigned char readbuf[2] = { 0, 0 };
|
|
int ret = usb_bulk_read(dh, 1, (char*)readbuf, 2, 10);
|
|
if (ret <= 0)
|
|
return;
|
|
fprintf(stderr, "Unexpected data word from device: 0x%02x 0x%02x (%d)\n", readbuf[0], readbuf[1], ret);
|
|
}
|
|
}
|
|
|
|
int fx2usb_send_chunk(usb_dev_handle *dh, int ep, const void *data, int len)
|
|
{
|
|
int ret;
|
|
#if 0
|
|
if (ep == 2) {
|
|
int i;
|
|
fprintf(stderr, "<ep2:%4d bytes> ...", len);
|
|
for (i = len-16; i < len; i++) {
|
|
if (i < 0)
|
|
continue;
|
|
fprintf(stderr, " %02x", ((unsigned char*)data)[i]);
|
|
}
|
|
fprintf(stderr, "\n");
|
|
}
|
|
#endif
|
|
retry_write:
|
|
ret = usb_bulk_write(dh, ep, data, len, 1000);
|
|
if (ret == -ETIMEDOUT) {
|
|
fprintf(stderr, "fx2usb_recv_chunk: usb write timeout -> retry\n");
|
|
fx2usb_flush(dh);
|
|
goto retry_write;
|
|
}
|
|
if (ret != len)
|
|
fprintf(stderr, "fx2usb_send_chunk: write of %d bytes to ep %d returned %d: %s\n", len, ep, ret, ret >= 0 ? "NO ERROR" : usb_strerror());
|
|
return ret == len ? 0 : -1;
|
|
}
|
|
|
|
int fx2usb_recv_chunk(usb_dev_handle *dh, int ep, void *data, int len, int *ret_len)
|
|
{
|
|
int ret;
|
|
retry_read:
|
|
ret = usb_bulk_read(dh, ep, data, len, 1000);
|
|
if (ret == -ETIMEDOUT) {
|
|
fprintf(stderr, "fx2usb_recv_chunk: usb read timeout -> retry\n");
|
|
goto retry_read;
|
|
}
|
|
if (ret > 0 && ret_len != NULL)
|
|
len = *ret_len = ret;
|
|
if (ret != len)
|
|
fprintf(stderr, "fx2usb_recv_chunk: read of %d bytes from ep %d returned %d: %s\n", len, ep, ret, ret >= 0 ? "NO ERROR" : usb_strerror());
|
|
return ret == len ? 0 : -1;
|
|
}
|
|
|