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);
}
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_read_chunk_size(unsigned int chunksize)
{
return ftdi_read_data_set_chunksize(d->ftdi, chunksize);
}
static int dev_open(struct sr_dev_inst *sdi)
{
struct dev_context *devc;
int ret;
devc = sdi->priv;
/* Select interface A, otherwise communication will fail. */
ret = ftdi_set_interface(devc->ftdic, INTERFACE_A);
if (ret < 0) {
sr_err("Failed to set FTDI interface A (%d): %s", ret,
ftdi_get_error_string(devc->ftdic));
return SR_ERR;
}
sr_dbg("FTDI chip interface A set successfully.");
/* Open the device. */
ret = ftdi_usb_open_desc(devc->ftdic, USB_VENDOR_ID, USB_DEVICE_ID,
USB_IPRODUCT, NULL);
if (ret < 0) {
sr_err("Failed to open device (%d): %s", ret,
ftdi_get_error_string(devc->ftdic));
return SR_ERR;
}
sr_dbg("FTDI device opened successfully.");
/* Purge RX/TX buffers in the FTDI chip. */
if ((ret = ftdi_usb_purge_buffers(devc->ftdic)) < 0) {
sr_err("Failed to purge FTDI RX/TX buffers (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_dev_open_close_ftdic;
}
sr_dbg("FTDI chip buffers purged successfully.");
/* Reset the FTDI bitmode. */
ret = ftdi_set_bitmode(devc->ftdic, 0xff, BITMODE_RESET);
if (ret < 0) {
sr_err("Failed to reset the FTDI chip bitmode (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_dev_open_close_ftdic;
}
sr_dbg("FTDI chip bitmode reset successfully.");
/* Set FTDI bitmode to "sync FIFO". */
ret = ftdi_set_bitmode(devc->ftdic, 0xff, BITMODE_SYNCFF);
if (ret < 0) {
sr_err("Failed to put FTDI chip into sync FIFO mode (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_dev_open_close_ftdic;
}
sr_dbg("FTDI chip sync FIFO mode entered successfully.");
/* Set the FTDI latency timer to 2. */
ret = ftdi_set_latency_timer(devc->ftdic, 2);
if (ret < 0) {
sr_err("Failed to set FTDI latency timer (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_dev_open_close_ftdic;
}
sr_dbg("FTDI chip latency timer set successfully.");
/* Set the FTDI read data chunk size to 64kB. */
ret = ftdi_read_data_set_chunksize(devc->ftdic, 64 * 1024);
if (ret < 0) {
sr_err("Failed to set FTDI read data chunk size (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_dev_open_close_ftdic;
}
sr_dbg("FTDI chip read data chunk size set successfully.");
/* Get the ScanaPLUS device ID from the FTDI EEPROM. */
if ((ret = scanaplus_get_device_id(devc)) < 0) {
sr_err("Failed to get ScanaPLUS device ID: %d.", ret);
goto err_dev_open_close_ftdic;
}
sr_dbg("Received ScanaPLUS device ID successfully: %02x %02x %02x.",
devc->devid[0], devc->devid[1], devc->devid[2]);
sdi->status = SR_ST_ACTIVE;
return SR_OK;
err_dev_open_close_ftdic:
scanaplus_close(devc);
return SR_ERR;
}
void sample(uint32_t baudrate) {
int vid = 0x403;
int pid = 0x6010;
struct ftdi_context *ftdi;
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
exit(EXIT_FAILURE);
}
ftdi_set_interface(ftdi, 1);
ftdi_read_data_set_chunksize(ftdi, 1<<14);
uint32_t chunksize = 0;
ftdi_read_data_get_chunksize(ftdi,&chunksize);
printf("%i\n\r",chunksize);
int f = 0;
f = ftdi_usb_open(ftdi, vid, pid);
if (f < 0)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
exit(-1);
}
f = ftdi_set_baudrate(ftdi, baudrate);
if (f < 0)
{
fprintf(stderr, "unable to set baudrate: %d (%s)\n", f, ftdi_get_error_string(ftdi));
exit(-1);
}
f = ftdi_set_line_property(ftdi, 8, STOP_BIT_1, NONE);
if (f < 0)
{
fprintf(stderr, "unable to set line parameters: %d (%s)\n", f, ftdi_get_error_string(ftdi));
exit(-1);
}
FILE * raw = fopen("raw.bin","w");
if (raw == NULL) {
fprintf(stderr, "Value of errno: %d\n", errno);
perror("Error printed by perror");
fprintf(stderr, "Error opening file: %s\n", strerror(errno));
exit(EXIT_FAILURE);
}
int total_bytes = 0;
#define BUFFERLENGTH (uint16_t)2000
uint8_t buffer[BUFFERLENGTH];
uint16_t count = 0;
while (!exit_requested) {
count = ftdi_read_data(ftdi, buffer, BUFFERLENGTH);
fwrite(buffer, sizeof(char), count, raw);
total_bytes += count;
printf("\rTotal bytes: %d",total_bytes);
fflush(stdout);
}
printf("\n\rCleaning up...\n\r");
fflush(raw);
fclose(raw);
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
}
// 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
}
