int spectrig_connect(struct ftdi_context *ftdi)
{
int ret;
ftdi_init(ftdi);
/* TODO: Be a bit more selective and support multiple devices properly */
ret = open_by_desc_prefix(ftdi, 0x0403, 0x6010, spectrig_descs);
if (ret < 0) {
perror("Failed to open the device");
return ret;
}
ftdi_usb_purge_buffers(ftdi);
/* Initialize synchronous communication */
ret = ftdi_set_latency_timer(ftdi, 2);
if (ret < 0) {
perror("Failed to set the latency timer");
goto close;
}
ret = ftdi_read_data_set_chunksize(ftdi, 0x10000);
if (ret < 0) {
perror("Failed to set read data chunksize");
goto close;
}
ret = ftdi_write_data_set_chunksize(ftdi, 0x10000);
if (ret < 0) {
perror("Failed to write read data chunksize");
goto close;
}
ret = ftdi_setflowctrl(ftdi, SIO_RTS_CTS_HS);
if (ret < 0) {
perror("Failed to set flow control");
goto close;
}
msleep(20);
ret = ftdi_set_bitmode(ftdi, 0xff, 0x00);
if (ret < 0) {
perror("Failed to set bitmode 0x00");
goto close;
}
msleep(20);
ftdi_set_bitmode(ftdi, 0xff, 0x40);
if (ret < 0) {
perror("Failed to set bitmode 0x40");
goto close;
}
msleep(300);
ftdi_usb_purge_buffers(ftdi);
return 0;
close:
ftdi_usb_close(ftdi);
ftdi_deinit(ftdi);
return ret;
}
static int jtagkey_init(unsigned short vid, unsigned short pid) {
int ret = 0;
unsigned char c;
if ((ret = ftdi_init(&ftdic)) != 0) {
fprintf(stderr, "unable to initialise libftdi: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_usb_open(&ftdic, vid, pid)) != 0) {
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_usb_reset(&ftdic)) != 0) {
fprintf(stderr, "unable reset device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_set_interface(&ftdic, INTERFACE_A)) != 0) {
fprintf(stderr, "unable to set interface: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_write_data_set_chunksize(&ftdic, USBBUFSIZE)) != 0) {
fprintf(stderr, "unable to set write chunksize: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_read_data_set_chunksize(&ftdic, USBBUFSIZE)) != 0) {
fprintf(stderr, "unable to set read chunksize: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = jtagkey_latency(OTHER_LATENCY)) != 0)
return ret;
c = 0x00;
ftdi_write_data(&ftdic, &c, 1);
if ((ret = ftdi_set_bitmode(&ftdic, JTAGKEY_TCK|JTAGKEY_TDI|JTAGKEY_TMS|JTAGKEY_OEn, BITMODE_SYNCBB)) != 0) {
fprintf(stderr, "unable to enable bitbang mode: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_set_baudrate(&ftdic, JTAG_SPEED)) != 0) {
fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_usb_purge_buffers(&ftdic)) != 0) {
fprintf(stderr, "unable to purge buffers: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
return ret;
}
struct ftdi_context *
bub_init(unsigned int baud_rate,
unsigned char latency,
unsigned int tx_buf_size,
unsigned int rx_buf_size) {
int ret = 0;
struct ftdi_context *ftdic;
ftdic = malloc(sizeof(struct ftdi_context));
if(ftdic == NULL) {
perror("malloc");
return(NULL);
}
ret = ftdi_init(ftdic);
if (ret < 0) {
fprintf(stderr, "ftdi_init failed: %d.\n", ret);
return(NULL);
}
ftdi_set_interface(ftdic, INTERFACE_ANY);
ret = ftdi_usb_open(ftdic, 0x0403, 0x6001); // FIXME make nice defines
if(ret < 0) {
fprintf(stderr, "unable to open ftdi device: %d (%s)\n",
ret, ftdi_get_error_string(ftdic));
return(NULL);
}
if(ftdi_usb_reset(ftdic) != 0)
fprintf(stderr, "WARN: ftdi_usb_reset failed!\n");
ftdi_disable_bitbang(ftdic);
if (ftdi_set_baudrate(ftdic, baud_rate) < 0) {
fprintf(stderr, "Unable to set baudrate: (%s)\n",
ftdi_get_error_string(ftdic));
return(NULL);
}
ftdi_set_latency_timer(ftdic, latency);
if(tx_buf_size > 0)
ftdi_write_data_set_chunksize(ftdic, tx_buf_size);
if(rx_buf_size > 0)
ftdi_read_data_set_chunksize(ftdic, rx_buf_size);
return(ftdic);
}
int platform_init(void)
{
int err;
if(ftdic) {
ftdi_usb_close(ftdic);
ftdi_free(ftdic);
ftdic = NULL;
}
if((ftdic = ftdi_new()) == NULL) {
fprintf(stderr, "ftdi_new: %s\n",
ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_set_interface(ftdic, INTERFACE_A)) != 0) {
fprintf(stderr, "ftdi_set_interface: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_usb_open(ftdic, FT2232_VID, FT2232_PID)) != 0) {
fprintf(stderr, "unable to open ftdi device: %d (%s)\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_set_latency_timer(ftdic, 1)) != 0) {
fprintf(stderr, "ftdi_set_latency_timer: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_set_baudrate(ftdic, 1000000)) != 0) {
fprintf(stderr, "ftdi_set_baudrate: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_usb_purge_buffers(ftdic)) != 0) {
fprintf(stderr, "ftdi_set_baudrate: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_write_data_set_chunksize(ftdic, BUF_SIZE)) != 0) {
fprintf(stderr, "ftdi_write_data_set_chunksize: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
assert(gdb_if_init() == 0);
jtag_scan(NULL);
return 0;
}
int
USBPort::send_packet (unsigned char packet[PACKETSIZE])
{
ftdi_write_data_set_chunksize (&ftdic, 1);
//printf("Send: P0 %c, P71 %c\n", packet[0], packet[71]);
int bytesSent;
for (bytesSent = 0; bytesSent < PACKETSIZE; bytesSent++)
this->send_char (packet[bytesSent]);
//printf ("Bytes: %d\n", bytesSent);
//fprintf(stderr, "Error: (%s)\n", ftdi_get_error_string(&ftdic));
return bytesSent;
}
Ft245sync::Ft245sync(unsigned int chunkSizeRead,
unsigned int chunkSizeWrite,
uint8_t gpio,
struct ftdi_context * vftdic,
struct ftdi_context * vftdic2)
{
if(vftdic == NULL)
{
this->ftdic = static_cast<struct ftdi_context*>(malloc(sizeof(struct ftdi_context)));
}
else
{
this->ftdic = vftdic;
}
if(vftdic2 == NULL)
{
this->ftdic2 = static_cast<struct ftdi_context*>(malloc(sizeof(struct ftdi_context)));
}
else
{
this->ftdic2 = vftdic2;
}
int f;
// Init 1. channel
if (ftdi_init(ftdic) < 0)
{
throw Exception("ftdi_init failure\n");
}
ftdi_set_interface(ftdic, INTERFACE_A);
f = ftdi_usb_open(ftdic, 0x0403, PID);
if (f < 0 && f != -5)
{
throw Exception("Unable to open FTDI device, channel A\n");
}
// Init 2. channel
if (ftdi_init(ftdic2) < 0)
{
throw Exception("ftdi_init failure\n");
}
ftdi_usb_reset(ftdic);
ftdi_usb_reset(ftdic2);
ftdi_set_interface(ftdic2, INTERFACE_B);
f = ftdi_usb_open(ftdic2, 0x0403, PID);
if (f < 0 && f != -5)
{
throw Exception("Unable to open FTDI device, channel B\n");
}
ftdi_write_data_set_chunksize(ftdic2, 512);
ftdi_set_interface(ftdic2, INTERFACE_B);
ftdi_usb_reset(ftdic2);
ftdi_set_latency_timer(ftdic2, 2);
ftdi_setflowctrl(ftdic2, SIO_RTS_CTS_HS);
ftdi_set_bitmode(ftdic2, 0, BBMODE_SPI);
uint8_t buf[3];
buf[0] = SET_BITS_LOW;
buf[1] = 8;
buf[2] = BIT_DIR; //holding programming of FPGA*/
ftdi_write_data(ftdic2, buf, 3);
buf[0] = SET_BITS_HIGH;
buf[1] = 0xFF; //lighting leds
buf[2] = BIT_DIR;
ftdi_write_data(ftdic2, buf, 3);
buf[0] = SET_BITS_HIGH;
buf[1] = 0x00; //lighting leds
buf[2] = BIT_DIR;
ftdi_write_data(ftdic2, buf, 3);
buf[0] = SET_BITS_LOW;
buf[1] = gpio;
buf[2] = BIT_DIR; //releasing programming of FPGA
ftdi_write_data(ftdic2, buf, 3);
sleep(1);
buf[0] = SET_BITS_LOW;
buf[1] = 0xFF; //reseting design in FPGA
buf[2] = BIT_DIR;
ftdi_write_data(ftdic2, buf, 3);
sleep(1);
buf[0] = SET_BITS_LOW;
buf[1] = 0xDD; //releasing reset
buf[2] = BIT_DIR;
ftdi_write_data(ftdic2, buf, 3);
sleep(1);
buf[0] = SET_BITS_HIGH;
buf[1] = 0xFF; //lighting leds
buf[2] = BIT_DIR;
ftdi_write_data(ftdic2, buf, 3);
if (ftdi_usb_purge_buffers(ftdic2))
{
throw Exception("Purging buffers failed\n");
}
ftdi_usb_close(ftdic2); // close channel 2
ftdi_deinit(ftdic2); // close channel 2
ftdic->usb_read_timeout = READ_TIMEOUT;
ftdic->usb_write_timeout = WRITE_TIMEOUT;
ftdi_read_data_set_chunksize(ftdic, chunkSizeRead);
ftdi_write_data_set_chunksize(ftdic, chunkSizeWrite);
if (ftdi_usb_reset(ftdic))
{
throw Exception("Reset failed\n");
}
usleep(1000);
if(ftdi_usb_purge_buffers(ftdic) < 0)
{
throw Exception("Setting FT2232 synchronous bitmode failed\n");
}
if(ftdi_set_bitmode(ftdic, 0xFF, 0x00) < 0)
{
throw Exception("Setting FT2232 synchronous bitmode failed\n");
}
if(ftdi_set_bitmode(ftdic, 0xFF, 0x40) < 0)
{
throw Exception("Setting FT2232 synchronous bitmode failed\n");
}
if (ftdi_set_latency_timer(ftdic, 2)) /* AN_130 */
{
throw Exception("Set latency failed failed\n");
}
//SetUSBParameters(ftHandle,0x10000, 0x10000);
if (ftdi_setflowctrl(ftdic, SIO_RTS_CTS_HS)) // AN_130
{
throw Exception("Set RTS_CTS failed\n");
}
/*if(ftdi_usb_purge_buffers(ftdic) < 0)
{
throw Exception("Setting FT2232 synchronous bitmode failed\n");
}*/
//fixes unalignment of first read (should be fixed in cleaner manner)
usleep(400);
unsigned char cleanup[10] = { 0xBB, 0xBB, 0xBB, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA };
ftdi_write_data(ftdic, cleanup, 10);
unsigned char recvbuf[4000];
read(recvbuf);
}
int Context::set_write_chunk_size(unsigned int chunksize)
{
return ftdi_write_data_set_chunksize(d->ftdi, chunksize);
}
void platform_init(int argc, char **argv)
{
int err;
int c;
unsigned index = 0;
char *serial = NULL;
char * cablename = "ftdi";
while((c = getopt(argc, argv, "c:s:")) != -1) {
switch(c) {
case 'c':
cablename = optarg;
break;
case 's':
serial = optarg;
break;
}
}
for(index = 0; index < sizeof(cable_desc)/sizeof(cable_desc[0]);
index++)
if (strcmp(cable_desc[index].name, cablename) == 0)
break;
if (index == sizeof(cable_desc)/sizeof(cable_desc[0])){
fprintf(stderr, "No cable matching %s found\n",cablename);
exit(-1);
}
active_cable = &cable_desc[index];
printf("\nBlack Magic Probe (" FIRMWARE_VERSION ")\n");
printf("Copyright (C) 2015 Black Sphere Technologies Ltd.\n");
printf("License GPLv3+: GNU GPL version 3 or later "
"<http://gnu.org/licenses/gpl.html>\n\n");
if(ftdic) {
ftdi_usb_close(ftdic);
ftdi_free(ftdic);
ftdic = NULL;
}
if((ftdic = ftdi_new()) == NULL) {
fprintf(stderr, "ftdi_new: %s\n",
ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_set_interface(ftdic, active_cable->interface)) != 0) {
fprintf(stderr, "ftdi_set_interface: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_usb_open_desc(
ftdic, active_cable->vendor, active_cable->product,
active_cable->description, serial)) != 0) {
fprintf(stderr, "unable to open ftdi device: %d (%s)\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_set_latency_timer(ftdic, 1)) != 0) {
fprintf(stderr, "ftdi_set_latency_timer: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_set_baudrate(ftdic, 1000000)) != 0) {
fprintf(stderr, "ftdi_set_baudrate: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_write_data_set_chunksize(ftdic, BUF_SIZE)) != 0) {
fprintf(stderr, "ftdi_write_data_set_chunksize: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
assert(gdb_if_init() == 0);
}
// init serial communication device
bool CPlatform::initSerial(char*cPort, unsigned int baudrate)
{
// Windows
#ifdef WIN32
if(hSerialPort != INVALID_HANDLE_VALUE) {
CloseHandle(hSerialPort);
}
if(cPort == NULL) {
cPort = STDSERIALWINDOWS;
}
hSerialPort = ::CreateFile(cPort, GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if(hSerialPort == INVALID_HANDLE_VALUE) {
CUtil::cout("initSerial: CreateFile() failed.\n", TEXT_ERROR);
return false;
}
else {
CUtil::cout("initSerial: Connected!\n", TEXT_ERROR);
}
COMMTIMEOUTS timeouts;
GetCommTimeouts(hSerialPort, &timeouts);
int a = 40; //40
timeouts.ReadIntervalTimeout = a;
timeouts.ReadTotalTimeoutMultiplier = 20;
timeouts.ReadTotalTimeoutConstant = a;
timeouts.WriteTotalTimeoutMultiplier = 20;
timeouts.WriteTotalTimeoutConstant = a;
SetCommTimeouts(hSerialPort, &timeouts);
DCB dcb = {0};
dcb.DCBlength = sizeof(DCB);
if(!::GetCommState(hSerialPort, &dcb) ) {
CUtil::cout("initSerial: GetCommState() failed.\n", TEXT_ERROR);
}
else {
// 8bit, no parity, one stopbit
dcb.BaudRate = baudrate;
dcb.ByteSize = 8;
dcb.Parity = 0;
dcb.StopBits = 0;
if(!::SetCommState(hSerialPort, &dcb) ) {
CUtil::cout("initSerial: SetCommState() failed.\n", TEXT_ERROR);
}
}
return true;
// LINUX
#else
if(cPort == NULL) {
cPort = (char *)STDSERIALLINUX;
}
#ifdef USE_FTDI
/* Still testing */
unsigned char buf [1000];
int a;
int rsize;
if (ftdi_init(&ftdi) < 0 )
return false;
int ret;
if((ret = ftdi_usb_open(&ftdi, 0x0403, 0x6001)) < 0) {
printf( "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(&ftdi));
return EXIT_FAILURE;
}
// Read out FTDIChip-ID of R type chips
if (ftdi.type == TYPE_R) {
unsigned int chipid;
printf("ftdi_read_chipid: %d\n", ftdi_read_chipid(&ftdi, &chipid));
printf("FTDI chipid: %X\n", chipid);
}
ftdi_read_data_set_chunksize(&ftdi, 4096);
ftdi_write_data_set_chunksize(&ftdi, 4096);
ftdi_set_line_property2(&ftdi, BITS_8, STOP_BIT_1, NONE, BREAK_OFF);
ftdi_usb_reset (&ftdi);
printf("baudrate: %d\n", ftdi_set_baudrate (&ftdi, baudrate));
ftdi_setflowctrl(&ftdi, SIO_DISABLE_FLOW_CTRL);
ftdi_set_latency_timer(&ftdi, 1);
ftdi_usb_purge_buffers (&ftdi);
printf (" Err : %s \n", ftdi.error_str);
unsigned char nix[150];
int j = 0;
int cr;
for (j = 0; j < 10; j++) {
cr = ftdi_read_data (&ftdi, &nix[0], 100);
printf (" %i \n", cr);
}
printf ("Typ: %d\n", ftdi.type);
printf ("usb_read_timeout: %d\n", ftdi.usb_read_timeout);
printf ("usb_write_timeout: %d\n",
ftdi.usb_write_timeout);
printf ("baudrate: %d\n", ftdi.baudrate);
printf ("bitbang_enabled: %x\n", ftdi.bitbang_enabled);
printf ("bitbang_mode: %x\n", ftdi.bitbang_mode);
return true;
/* close handles */
ftdi_usb_close(&ftdi);
ftdi_deinit(&ftdi);
return false;
#endif
//system("stty -F /dev/ttyS0 speed 115200 raw cs8");
fdSerialPort = open(cPort, O_RDWR | O_NOCTTY | O_NDELAY);// | O_NONBLOCK | O_NDELAY);
if(fdSerialPort == -1) {
CUtil::cout("initSerial: open() failed.\n", TEXT_ERROR);
return false;
}
else {
CUtil::cout("initSerial: Connected.\n", TEXT_ERROR);
}
clearLine();
#ifndef SERIALDONTINIT
//fcntl(fdSerialPort, F_SETFL, FNDELAY);
struct termios options;
if(tcgetattr(fdSerialPort, &options) == -1) {
CUtil::cout("initSerial: tvgetattr() failed.\n", TEXT_ERROR);
}
else {
options.c_iflag = 0;
options.c_oflag = 0;
options.c_cflag = 0;
options.c_lflag = 0;
cfsetispeed(&options, getSpeedConstant(baudrate) );
cfsetospeed(&options, getSpeedConstant(baudrate) );
cfmakeraw(&options);
options.c_cflag |= (CLOCAL | CREAD);
// 8 bit, no parity, 1 stopbit
options.c_cflag |= CS8;
options.c_cflag &= ~CRTSCTS;
options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
// wait for 1 characters
options.c_cc[VMIN] = 1;
// timeout 1 seconds
options.c_cc[VTIME] = 1;
/*
cfsetispeed(&options, getSpeedConstant(baudrate));
cfsetospeed(&options, getSpeedConstant(baudrate));
//options.c_cflag = 0;
options.c_cflag |= (getSpeedConstant(baudrate) | CLOCAL | CREAD);
// 8 bit, no parity, 1 stopbit
options.c_cflag |= CS8;
options.c_cflag &= ~CRTSCTS;
//options.c_lflag = 0;
options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);*/
// testing -->
// <-- testing
/*
// baudrate >> 1152000
struct serial_struct nuts;
int arby;
if(ioctl(fdSerialPort, TIOCGSERIAL, &nuts) == -1)
CUtil::cout( "Serial: ioctl(*,TIOCGSERIAL,*) failed.\n");
nuts.custom_divisor = nuts.baud_base / 500000;
if (!(nuts.custom_divisor))
nuts.custom_divisor = 1;
arby = nuts.baud_base / nuts.custom_divisor;
nuts.flags &= ~ASYNC_SPD_MASK;
nuts.flags |= ASYNC_SPD_CUST;
if (ioctl(fdSerialPort, TIOCSSERIAL, &nuts) == -1)
CUtil::cout("Serial: ioctl(*, TIOCSSERIAL, *) failed.\n");
options.c_cflag |= B38400;
// wait for 1 characters
options.c_cc[VMIN] = 1;
// timeout 1 seconds
options.c_cc[VTIME] = 1;
*/
if(tcsetattr(fdSerialPort, TCSANOW, &options) != 0) {
CUtil::cout("initSerial: tcsetattr() failed.\n", TEXT_ERROR);
}
}
#endif
return true;
#endif
}
